Detalhes

Categoria: Oficina de Assembly

Atualização: Quinta, 18 Junho 2009 11:44

Autor: vovó Vicki

Acessos: 23201

Vitaminar um programa existente exige um bom conhecimento da estrutura e do funcionamento de executáveis. A proposta deste tutorial, baseado no texto publicado por razzia em 19.08.97, é reforçar as noções básicas através de um exercício de re-engenharia de um velho conhecido: o Bloco de Notas do Windows.

O Bloco de Notas (Notepad), entre outras limitações, não indica números de linha - algo que seria muito útil em diversas situações. Mesmo que você não veja vantagens em adicionar o número das linhas ao programa, talvez seja interessante saber como modificar um executável sem possuir seu código fonte.

Escrevi este tutorial em 2001. Na época, a versão do bloco de notas era de 08/06/2000. Sugiro que faça o download desta versão do executável para poder acompanhar o texto. Você o encontra na seção de downloads em Informática / Programação.

O procedimento WndProc

Para determinar o código que será adicionado precisamos investigar um pouco o programa alvo. O "coração" de qualquer programa Windows é o procedimento WndProc. Este procedimento é chamado pelo Windows toda vez que o usuário interage com a janela do programa. O Windows passa alguns parâmetros para este procedimento (por exemplo, a mensagem da janela) para que o WndProc possa saber o que ocorreu e efetuar a atualização da janela.

No caso do bloco de notas, o programa principal gera uma janela filha da classe "edit", que sempre ocupa o tamanho total da janela principal. Se quisermos imprimir nosso próprio texto na janela principal, será necessário reduzir o tamanho da janela filha para que ela não cubra a área total da janela principal. Cada vez que o usuário alterar o tamanho da janela principal, o Windows chama WndProc com a mensagem WM_SIZE. O procedimento WndProc reage a este evento e ajusta o tamanho da janela filha "edit" ao novo tamanho da janela principal.

Se localizarmos o procedimento WndProc será possível avaliar como ele lida com a mensagem WM_SIZE. Entre as várias maneiras de fazer isto, a mais fácil é através da função da API RegisterClass. O bloco de notas usa a função RegisterClassExA, função que registra uma classe janela para uso subsequente em chamadas para as funções CreateWindow ou CreateWindowEx.

ATOM RegisterClassEx( CONST WNDCLASSEX *lpwcx );

O parâmetro lpwcx é um ponteiro que aponta para uma estrutura do tipo WNDCLASSEX. Esta estrutura precisa ser preenchida com os atributos de classe apropriados antes do parâmetro ser passado para a função. Caso a função seja executada com sucesso, o valor de retorno é um atom que identifica unicamente a classe que está sendo registrada. Em caso de falha, o valor de retorno é zero.

Conhecendo a função e suas características, podemos usar o W32Dasm ou o IDA para obter o bloco de código que se referente à função. No W32Dasm, após carregar o programa, clique no item de menu Functions / Imports para abrir a janela com todas as funções importadas. Localize nesta janela a função USER32.RegisterClassExA e dê um duplo clique sobre a referência para ser levado ao código correspondente:

Caso você queira testar o IDA, carregue o programa, selecione o item de menu Jump / Jump to name (ou simplesmente Ctrl+L) para obter a janela de nomes. Selecione RegisterClassExA e digite [enter]. Você será levado ao seguinte trecho de código, que é a referência na seção .idata (seção das importações) da função procurada:

.idata:0040644C extrn RegisterClassExA:dword ; DATA XREF: sub_403140+71^r

Feche a janela de nomes e dê um duplo clique sobre a referência "sub_403140+71^r". Você será levado para a seção .text no seguinte ponto:

Conhecendo a localização do WndProc, vamos analisar o código correspondente a esta chamada. No W32Dasm, selecione o item de menu Goto / Goto Code Location e indique o endereço 401C8C. No IDA, basta dar um duplo clique sobre "sub_401C8C" para ser levado à subrotina:

Na linha 401C93 o programa checa o tipo de mensagem recebida e garante que seu valor esteja entre 1 e 5. Na linha seguinte, caso o valor seja maior do que 5 (nenhuma mensagem válida), salta para 401CAC. Caso a mensagem seja 5, salta para 401DA4, caso contrário continua determinando o tipo da mensagem. As mensagens válidas estão descritas em WM_SIZE, que representa o tipo da mensagem enviada para uma janela após seu tamanho ter sido modificado.

De posse dessas informações, fica claro que o programa checa a validade e o valor da mensagem para decidir que caminho tomar. Nós queremos esclarecer o que é feito caso WM_SIZE seja igual a 5 (SIZE_RESTORED), ou seja, o tamanho da janela foi modificado sem que ela tenha sido maximizada ou minimizada. Para isto, precisamos rastrear o salto que o programa efetua para o endereço 401DA4. No IDA, basta um duplo clique sobre "loc_401DA4" (no W32Dasm selecione Goto):

Analisando este trecho de código, nos deparamos com uma chamada à subrotina 40121B:

Note que aparentemente o manipulador (handle) da janela filha "edit" é armazenado no endereço (virtual) de nome hWnd. Para encontrar o valor de hWnd usando o IDA, selecione o item de menu View / Open subviews / Names (Shift+F4) para obter a janela de nomes. Nesta, selecione Search / Search (Alt+T) e digite o nome do endereço (hWnd): você encontrará hWndMain = 405000 e hWnd = 405004. Anote cuidadosamente estes endereços pois ainda vamos precisar muito deles!

Também podemos verificar que, para cada mensagem WM_SIZE, a janela filha "edit" é atualizada com uma chamada para MoveWindow com o novo tamanho da janela principal.

Criando o código adicional

Vimos que, para cada mensagem WM_SIZE, a janela-filha "edit" é atualizada através de uma chamada a MoveWindow de acordo com o novo tamanho da janela principal. Porém, queremos evitar que a janela-filha "edit" ocupe a área total da janela mãe, ou seja, teremos que criar uma rotina que gerencie a altura das janelas com valores diferentes. Lembrando do trecho de código onde estes parâmetros são utilizados:

Colocando um salto (jump) na linha 40122D, podemos fazer com que o programa faça um "desvio" para o nosso código, o qual irá alterar nHeight de acordo com nossas instruções antes de alcançar a chamada que atualiza o tamanho da janela-filha "edit". Para gerenciar o tamanho da janela-filha "edit", nosso novo código altera o valor original da altura para repassá-lo à função MoveWindow:

Código para alterar a altura da janela-filha "edit"

Observação: o desvio para nosso bloco de código vai ser obtido a partir de uma instrução jump que ocupará 5 bytes. Com isto, existem duas linhas do código original que serão "comidas" pelo jump e que precisam ser substituídas em algum ponto do nosso novo código. As duas linhas estão em 40122D e 401231. A primeira coloca no topo da pilha a altura (nHeight) da janela-filha com push [esp+C] e a segunda coloca no topo da pilha a largura (nWidth) da mesma janela-filha, também com um push [esp+C]. Como utilizamos o registrador EAX para calcular o novo valor da altura da janela-filha "edit", substituímos a linha 40122D push [esp+C] pela linha indicada em (1), colocando diretamente o valor de EAX no topo da pilha. A linha 401231 é substituída pela linha indicada em (2), mantendo a instrução push [esp+C].

Além disso, na linha indicada em (3), o valor calculado da nova altura é salvo no endereço 40DB70 porque vai ser necessário no módulo de código referente à impressão, citado logo adiante. A escolha do endereço das variáveis encontra-se logo abaixo na tabela de variáveis.

Após ter projetado o código para gerenciar o tamanho da janela-filha "edit", precisamos imprimir algum texto na janela principal (os números das linhas). Toda vez que uma janela precisa ser "repintada" (por exemplo, quando esteve encoberta por outra janela ou quando o usuário alterar seu tamanho), o Windows chama o procedimento WndProc com WM_PAINT. Isto significa que teremos que "caçar" a mensagem WM_PAINT e, novamente, forçar um salto para a nossa rotina que, desta vez, será um módulo que imprima texto.

Também precisamos imprimir texto toda vez que o cursor muda a sua posição vertical. A melhor maneira para conseguir isto é ignorar todas as mensagens possíveis que informem qualquer mudança na posição do cursor e passar a comparar a nova posição do cursor com a antiga.

Examinando o início do código do WndProc, nota-se que nada é feito com a mensagem WM_PAINT. Desta forma, no início do procedimento WndProc podemos inserir um salto (jump) para nosso módulo de código:

Novamente precisaremos de 5 bytes para forçar o salto. Temos espaço suficiente entre os endereços 401C8C e 401C90. O endereço para o retorno no nosso módulo de código será 401C93.

Código para imprimir números de linhas

Note que foram utilizadas algumas variáveis. Cada uma destas variáveis possui um endereço próprio. Alguns dos valores são alterados pelo próprio programa, outros precisam ser introduzidas através de um editor hexadecimal. Os endereços das variáveis foram escolhidos num bloco logo após o final do código:

Foram usadas somente funções da API do Windows já importadas pelo notepad.exe (verifique a tabela de importações). O que fazer caso seja necessário lançar mão de funções da API que não constem da tabela de importações? No final do tutorial há uma explicação de como proceder nestes casos.

Algumas funções necessitam do handle da janela principal como parâmetro. Já foi descrito anteriormente como encontrar este valor.

• (4) Nesta linha e nas três seguintes a chamada para a função SendMessageA é preparada. Esta função obtém o valor da coordenada Y do cursor e o retorna no registrador EAX.
• (6) Se a posição do cursor for 0 (zero), estamos na linha 1. Se for 1, estamos na linha 2, etc. Portanto, precisamos ajustar o valor da coordenada Y do cursor somando 1.
• (7) Preparamos os parâmetros da função wsprintfA.
• (9) A função wsprintfA transforma o número enviado como parâmetro em caracteres ASCII de acordo com a string de formatação e coloca o resultado no endereço especificado. Por exemplo, transforma 1 em "00001".
• (10) Para utilizar a função TabbedTextOut, precisamos primeiro obter o handle do contexto. Para isto chamamos a função GetDC com o parâmtero da janela principal (onde o texto deve ser impresso).
• (11) A função GetDC devolve o handle do contexto no registrador EAX. Como precisaremos deste handle para liberar o contexto, armazenamos seu valor na variável hContexto.
• (13) A função TabbedTextOut exige muitos parâmetros para imprimir a string enviada no local especificado. As 9 linhas anteriores à chamada preparam os parâmetros necessários.
• (14) Finalmente, após a impressão da string na janela mãe, precisamos liberar o contexto que foi bloqueado pela função GetDC. Para isto utilizamos a função ReleaseDC.

Enxertando o código no executável

Já temos um projeto de código, agora é preciso incluí-lo no executável. Mais uma vez, vamos por partes para não nos perdermos.

Inserindo o código da altura da janela

É preciso encontrar espaço ocioso no executável que possa ser utilizado para incluir o código. Usando o PE Explorer (faça o download do trial na Heaven Tools), verificamos o seguinte nos cabeçalhos das seções:

• Procurando espaço livre

Vamos tomar a seção .data como exemplo. Esta seção foi dimensionada para ocupar um espaço de 1000 (tamanho dos dados) a partir do endereço 405000. Seu tamanho virtual é 83C e o espaço total disponível é de 1000, indicando que ainda há 7C4 bytes livres (1000 - 83C = 7C4). Tudo isto no sistema hexadecimal. Transformando os números para o sistema decimal, apenas por curiosidade, sabemos que o espaço reservado é de 4096, o espaço ocupado é de 2108, restando portanto 1988 bytes livres.

A segunda maior sobra de espaço se encontra na seção .reloc, onde há 1362 (552 em hexa) bytes disponíveis. Vamos escolher a seção .reloc para abrigar nosso código adicional. Ele cabe perfeitamente neste espaço livre, portanto, não vai haver a necessidade de ampliar o tamanho da seção escolhida.

• Calculando o tamanho do salto

Segue-se agora uma longa jornada de cálculos. O primeiro deles será determinar o endereço do primeiro salto. Conforme visto anteriormente, foi decidido fazer um desvio no ponto onde o programa põe na pilha o valor da altura e da largura da janela-filha "edit". Reveja o trecho de código obtido através do debugador OllyDbg (note as referências preciosas que o programa fornece!):

O OllyDbg está disponível na seção de downloads em Informática / Debuggers.

Portanto, faremos um salto incondicional - jmp do endereço 40122D para o início do espaço vago da seção .reloc. Pelo cabeçalho de seções verificamos que o endereço virtual inicial de .reloc é 40D000 e nós queremos colocar o código adicional AAEh bytes adiante. Basta somar ao endereço virtual da seção o tamanho do código para obter o endereço inicial do código adicional, ou seja, 40D000 + AAE = 40DAAE. Nosso salto, então, deverá ser de 40122D para 40DAAE, o que corresponde a um salto de C881 bytes. Como sabemos que nossa instrução, por ser um salto longo, conterá 5 bytes, precisamos descontar os mesmos para calcular o valor correto para o salto: 40DAAE - 40122D - 5 = C87C.

De posse deste valor, vamos compor a instrução lembrando que a distância do salto é indicada em 4 bytes na ordem inversa, ou seja, 00 00 C8 7C será indicado como 7C C8 00 00:

Para o salto de retorno é preciso pular alguns bytes "para trás". No exemplo anterior, pulamos 51324 bytes "para frente", no retorno teremos que saltar 51343 bytes "para trás", ou seja, -51343 (menos 51343). Em hexadecimal, 401235 - 40DABF - 5 = FFFF3771.

• Alterando o código para o salto

O programa original deve sofrer as seguintes alterações para a introdução do salto:

Observe que ocupamos apenas o primeiro byte (FF) da instrução no endereço 401231 para poder completar nossa instrução de salto. Restaram os códigos 74, 24 e 0C que foram anulados com três instruções NOP (90) para manter íntegro o tamanho do código original e não desestruturar outros endereçamentos existentes. Com o salto devidamente inserido, este bloco de código passa a ser:

• Adicionando o código para alterar o tamanho da janela "edit"

Quando alcançar a linha 40122D, o salto é efetuado e a execução do código continua no endereço 40DAAE, exatamente o ponto onde vamos inserir o bloco 1 do código adicional. Nele, antes de refazermos as operações das linhas 40122D e 401231 que foram suprimidas para poder inserir o salto, a altura da janela "edit" é diminuída em 20 pixels. Para tanto, utilizamos o registrador EAX:

Use um editor hexadecimal (Hackman ou Hacker's View, por exemplo) e faça as alterações propostas numa cópia do programa notepad.exe (o Hacker's View permite a entrada de código assembly e calcula os jumps, o que facilita muito o trabalho). Qualquer um dos programas sugeridos mostra o código a partir da posição 0 (zero) e NÃO pelo endereço virtual. Portanto, é preciso conhecer a posição dos endereços virtuais pelo seu deslocamento (offset) a partir da posição zero. Isto se consegue subtraindo a base da imagem (00400000) do endereço pretendido. Por exemplo, o deslocamento do endereço 40122D é 122D (40122D - 400000 = 122D). Caso você encontre dificuldades, o W32Dasm indica no rodapé o offset de cada linha de código

• Testando a primeira etapa

Após fazer as modificações sugeridas é aconselhável testar o programa modificado. Tudo que esperamos é que a janela-filha "edit" tenha uma altura menor do que a janela principal. Se tudo correu bem, a janela do novo bloco de notas tem um "rodapé" de 20 pixels (a diferença de altura entre as duas janelas), o qual será usado para imprimir o texto com a indicação dos números das linhas.

Nova janela do bloco de notas

Inserindo o código de impressão

Já identificamos um espaço ocioso no executável onde é possível incluir o código, já sabemos como calcular a distância de saltos e onde inseri-los, então... vamos ao trabalho.

• Inserindo o segundo salto

Conforme já visto, decidimos fazer um desvio no início do procedimento WndProc. Reveja o trecho de código citado:

Portanto, faremos um salto incondicional - jmp do endereço 401C8D para um endereço após o final do nosso primeiro bloco de código. Deixamos alguns bytes zerados e iniciamos o segundo bloco de código em 40DACD (o primeiro bloco terminou em 40DABF). O salto, então, será de BE3B bytes (40DAC8 - 401C8D - 5 = BE3B).

De posse deste valor, vamos compor a instrução, lembrando novamente que a distância do salto é indicada em 4 bytes na ordem inversa, ou seja, 00 00 BE 3B será indicado como 3B BE 00 00

O programa original deve sofrer as seguintes alterações para a introdução do salto:

Observe que ocupamos apenas os dois primeiros bytes (8B e 75) da instrução no endereço 401C90 para poder completar a instrução de salto. Restou o código 0C, o qual foi anulado com uma instrução NOP (90) para manter íntegro o tamanho do código original e não desestruturar outros endereçamentos existentes. Com o salto devidamente inserido, este bloco de código passa a ser:

• Adicionando o código da impressão dos números de linha

Quando alcançar a linha 401C8D, o salto é efetuado e a execução do código continua no endereço 40DACD, exatamente onde vamos inserir o bloco 2 do código adicional. Nele, antes de qualquer outra coisa, vamos refazer as operações suprimidas pela introdução do salto incondicional repetindo o código original:

A seguir preparamos os parâmetros para a função SendMessageA da API do Windows e a chamamos. Lembre-se de que os parâmetros precisam ser colocados na pilha na ordem inversa (para que a função possa acessá-los na ordem correta). O endereço da função pode ser obtido através do PE Explorer, na janela "Imports", sob a rubrica USER32:

004064E4 function SendMessageA(
   hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM):
   LRESULT; stdcall; external 'user32.dll' name 'SendMessageA' index 537

No retorno da função SendMessageA, o registrador EAX contém a posição Y do cursor na janela-filha "edit", ou seja, a linha atual da janela. Como já designamos o local de armazenamento do valor da variável dwLinha (40DB78), podemos comparar o valor de ambos. Se houver diferença, significa que o cursor mudou de linha e o rodapé precisa ser atualizado. Se ambos forem iguais, podemos voltar ao código original.

Caso o cursor tenha trocado de linha, algumas medidas precisam ser tomadas: atualizar a variável dwLinha em 40DB78 com o novo valor, somar 1 ao número da linha que deve ser impresso porque as linhas iniciam sua numeração em 0 (linha 0 - imprimimos linha 1, linha 1 - imprimimos linha 2, etc) e fazer uma chamada à função wsprintfA para "montar" a string que deve aparecer no rodapé:

0040641C function wsprintf(
   Output: PAnsiChar; Format: PAnsiChar):
      Integer; stdcall; external 'user32.dll' name 'wsprintfA' index 692;

Esta função recebe o valor que deve ser "stringado" (o número ajustado da linha), a string "%#05d" que corresponde ao formato de número precedido de zeros em 5 casas (1 será 00001) e o endereço onde deve ser armazenado o resultado (40DB90 + 0A = 40DB9A). O endereço da nossa "variável" para a string do rodapé é 40DB90. Os caracteres " Linha : " ocupam 10 posições, portanto, queremos que, a partir da 11a. posição seja armazenado o número transformado em ASCII no formato indicado pela string de formatação:

Agora precisamos obter o contexto do ambiente da janela principal para prepararmos a impressão da string que se encontra pronta no endereço 40DB90 na posição que definimos como rodapé. Para obter e bloquear o contexto utilizamos a função GetDC. Logo a seguir, armazenamos o handle do contexto no endereço 40DBA0 porque precisaremos do mesmo para imprimir a string e para liberar o contexto bloqueado depois de efetuarmos a impressão.

004064D8 function GetDC(hWnd: HWND):
   HDC; stdcall; external 'user32.dll' name 'GetDC' index 257;

Tudo pronto para imprimir! A função utilizada é a TabbedTextOutA que se encarregará de transferir a string " Linha : 0000x" localizada no endereço 40DB90 para o rodapé da janela principal. Esta função exige uma pá de parâmetros:

00406468 function TabbedTextOut
  (hdc: HDC; X, Y: Integer; lpString: PAnsiChar; nCount, nTabPositions: Integer;
   var lpnTabStopPositions; nTabOrigin: Integer):
    Longint; stdcall; external 'user32.dll' name 'TabbedTextOutA' index 633;

Ufa ! Está por pouco... só falta liberar o contexto para poder voltar ao código original. A função que utilizamos é a ReleaseDC:

004064DC function ReleaseDC(hWnd: HWND; hDc: HDC):
  Integer; stdcall; external 'user32.dll' name 'ReleaseDC' index 520;

Hora de voltar para o código principal. Porém, observando o Stack Pointer (ESP - Ponteiro da Pilha), verificamos que fizemos uma salada com tantos pushes. Avançamos 12 bytes que precisam ser "corrigidos" para evitar erros em referências posteriores. Como sabemos que a pilha "anda ao contrário", para DESCER 12 bytes precisamos SOMAR estas posições (12 dec = 0C hexa).

Fazendo os remendos (patches)

Para não perder tempo é preciso planejar. Planejamos o perfil do código, planejamos sua inserção no executável e agora vamos por a mão na massa. Para inserir os bytes referentes às instruções do primeiro bloco de código, podemos usar (se é que você já não usou) qualquer editor hexadecimal. Afinal, não é tanto código assim.

Para o segundo bloco de código sugiro o uso do Hacker's View (HIEW), pois permite a inserção direta do código assembly, além de calcular os deslocamentos dos jumps. Isto facilita muito o trabalho. Faça as alterações propostas numa cópia do programa notepad.exe.

Os editores mais conhecidos, como você já sabe, mostram o código a partir da posição 0 (zero) e NÃO pelo endereço virtual. Portanto, precisamos conhecer a posição dos endereços virtuais pelo seu deslocamento (offset) a partir da posição zero, o que se consegue subtraindo a base da imagem (00400000) do endereço pretendido. Por exemplo, o deslocamento do endereço 40DACD é DACD (40DACD - 400000 = DACD). Caso você encontre dificuldades, o W32Dasm indica no rodapé o offset de cada linha de código.

Após incluir os dois blocos de código, NÃO SE ESQUEÇA das variáveis. Duas delas precisam ser definidas: a string de formatação e a string do número de linha (veja em tabela de variáveis). Ainda com o editor hexadecimal da sua preferência vá até o offset DB80 e digite o valor da string de formatação. No offset DB90 digite a string do número de linha. Observe que há dois espaços (20 20) antes da palavra linha.

Testando o novo bloco de notas

Finalmente podemos testar o programa modificado. Já sabemos que a janela-filha "edit" tem uma altura menor do que a janela principal, formando um "rodapé" de 20 pixels (a diferença de altura entre as duas janelas). Este rodapé é usado para imprimir o texto com a indicação dos números de linha. Se tudo estiver em ordem, o aspecto do novo notepad será este:

Bloco de notas com número de linha

Recado da vó Vicki

Se você conseguiu chegar até o final deste artigo sem perder o fôlego, considere-se um herói da resistência. Agora, se além de acompanhar o texto ainda conseguiu reproduzir a experiência desta oficina de informática e criar seu bloco de notas com números de linha, seja bem vindo ao clube dos "malucos beleza", os escovadores de bits adeptos da co-engenharia que conseguiram se safar da camisa de força