Estou tentando aprender sobre engenharia reversa, usando o Campo Minado como um aplicativo de amostra. Eu encontrei este artigo do MSDN sobre um comando WinDbg simples que revela todas as minas, mas é antigo, não é explicado em detalhes e realmente não é o que estou procurando.
Tenho o desmontador IDA Pro e o depurador WinDbg e carreguei o winmine.exe em ambos. Alguém pode fornecer algumas dicas práticas para qualquer um desses programas em termos de encontrar a localização da estrutura de dados que representa o campo minado?
No WinDbg posso definir pontos de interrupção, mas é difícil para mim imaginar em que ponto definir um ponto de interrupção e em que local de memória. Da mesma forma, quando vejo o código estático no IDA Pro, não tenho certeza de onde começar a encontrar a função ou estrutura de dados que representa o campo minado.
Existe algum engenheiro reverso no Stackoverflow que pode me apontar na direção certa?
fonte
Respostas:
Parte 1 de 3
Se você é sério em engenharia reversa - esqueça os treinadores e os mecanismos de trapaça.
Uma boa engenharia reversa deve primeiro conhecer o sistema operacional, as funções básicas da API, a estrutura geral do programa (o que é loop de execução, estruturas do Windows, rotinas de tratamento de eventos), formato de arquivo (PE). Os clássicos "Janelas de programação" da Petzold podem ajudar (www.amazon.com/exec/obidos/ISBN=157231995X), bem como MSDN online.
Primeiro você deve pensar sobre onde a rotina de inicialização do campo minado pode ser chamada. Pensei em seguir:
Decidi verificar o comando do acelerador F2.
Para localizar o código de manipulação do acelerador, você deve encontrar o procedimento de manipulação de mensagens da janela (WndProc). Ele pode ser rastreado por chamadas CreateWindowEx e RegisterClass.
Ler:
Abra a janela IDA, Importações, encontre "CreateWindow *", vá até ela e use o comando "Jump xref to operand (X)" para ver onde ela é chamada. Deve haver apenas uma chamada.
Agora procure a função RegisterClass e seu parâmetro WndClass.lpfnWndProc acima. Já chamei a função mainWndProc no meu caso.
Pressione Enter no nome da função (use 'N' para renomeá-la para algo melhor)
Agora dê uma olhada em
Este é o id da mensagem, que no caso de pressionar o botão F2 deve conter o valor WM_COMMAND. Você deve descobrir onde está em comparação com 111h. Isso pode ser feito rastreando edx no IDA ou definindo um ponto de interrupção condicional no WinDbg e pressionando F2 no jogo.
Qualquer uma das formas leva a algo como
Clique com o botão direito em 111h e use "Constante simbólica" -> "Usar constante simbólica padrão", digite WM_ e pressione Enter. Agora você deve ter
É uma maneira fácil de descobrir os valores de id da mensagem.
Para entender o manuseio do acelerador, verifique:
É muito texto para uma única resposta. Se você estiver interessado, posso escrever mais alguns posts. Longa história curta campo minado armazenado como uma matriz de bytes [24x36], 0x0F mostra que o byte não é usado (jogando campo menor), 0x10 - campo vazio, 0x80 - meu.
Parte 2 de 3
Ok, vamos continuar com o botão F2.
De acordo com o uso de aceleradores de teclado quando o botão F2 é pressionado função wndProc
Ok, já encontramos onde WM_COMMAND é processado, mas como determinar o valor do parâmetro wParam correspondente? É aqui que entra em jogo o Resource hacker . Alimente-o com binários e ele mostra tudo. Como mesa de aceleradores para mim.
texto alternativo http://files.getdropbox.com/u/1478671/2009-07-29_161532.jpg
Você pode ver aqui que o botão F2 corresponde a 510 em wParam.
Agora vamos voltar ao código, que manipula WM_COMMAND. Ele compara wParam com diferentes constantes.
Use o menu de contexto ou o atalho de teclado 'H' para exibir os valores decimais e você pode ver nosso salto
Isso leva a um pedaço de código que chama algum proc e sai de wndProc.
É essa função que inicia um novo jogo? Descubra isso na última parte! Fique ligado.
Parte 3 de 3
Vamos dar uma olhada na primeira parte dessa função
Existem dois valores (dword_10056AC, uValue) lidos nos registros eax e ecx e comparados a outros dois valores (dword_1005164, dword_1005338).
Dê uma olhada nos valores reais usando WinDBG ('bp 01003696'; no intervalo 'p eax; p ecx') - eles pareciam dimensões de campo minado para mim. Jogar com o tamanho do campo minado personalizado mostrou que o primeiro par são novas dimensões e o segundo - dimensões atuais. Vamos definir novos nomes.
Um pouco mais tarde, os novos valores sobrescrevem a corrente e a sub-rotina é chamada
E quando eu vi isso
Eu tinha certeza de que havia encontrado um campo minado Causa do ciclo que inicia a matriz de comprimento de bytes de 360h (dword_1005340) com 0xF.
Por que 360h = 864? Existem algumas dicas abaixo de que a linha ocupa 32 bytes e 864 podem ser divididos por 32, então a matriz pode conter 27 * 32 células (embora a IU permita no máximo 24 * 30 campos, há um preenchimento de byte ao redor da matriz para as bordas).
O código a seguir gera as bordas superior e inferior do campo minado (byte 0x10). Espero que você possa ver a iteração do loop nessa bagunça;) Eu tive que usar papel e caneta
E o resto da sub-rotina desenha as bordas esquerda e direita
O uso inteligente de comandos WinDBG pode fornecer a você um excelente despejo de campo minado (tamanho personalizado 9x9). Verifique as fronteiras!
Hmm, parece que vou precisar de outro post para fechar o tópico
fonte
Parece que você está tentando desmontar a fonte, mas o que você precisa fazer é verificar o espaço de memória do programa em execução. O editor hexadecimal HxD tem um recurso que permite exatamente isso.
Uma vez no espaço da memória, é uma questão de tirar instantâneos da memória enquanto você mexe no tabuleiro. Isole o que muda e o que não muda. Quando você achar que sabe onde está a estrutura de dados na memória hexadecimal, tente editá-la enquanto ela estiver na memória e ver se a placa muda como resultado.
O processo que você deseja não é diferente de construir um 'treinador' para um videogame. Geralmente, essas informações baseiam-se em descobrir onde valores como saúde e munição vivem na memória e alterá-los em tempo real. Você pode encontrar alguns bons tutoriais sobre como construir treinadores de jogos.
fonte
Confira este artigo de projeto de código, é um pouco mais detalhado do que a postagem do blog que você mencionou.
http://www.codeproject.com/KB/trace/minememoryreader.aspx
Editar
E este artigo, embora não seja diretamente sobre o campo minado, fornece um bom guia passo a passo sobre como caçar na memória usando o WinDbg:
http://www.codingthewheel.com/archives/extracting-hidden-text-with-windbg
Editar 2
Novamente, não se trata de caça-minas, mas definitivamente me deu um pouco de reflexão para depurar minha memória. Há uma abundância de tutoriais aqui:
http://memoryhacking.com/forums/index.php
Além disso, baixe o CheatEngine (mencionado por Nick D.) e trabalhe no tutorial que vem com ele.
fonte
Exatamente!
Bem, você pode procurar rotinas como random () que serão chamadas durante a construção da tabela de minas. Este livro me ajudou muito quando eu estava fazendo experiências com engenharia reversa. :)
Em geral, bons lugares para definir pontos de interrupção são chamadas para caixas de mensagem, chamadas para reproduzir um som, temporizadores e outras rotinas de API win32.
BTW, estou digitalizando o caça-minas agora com OllyDbg .
Atualização: nemo me lembrou uma ótima ferramenta, Cheat Engine de Eric "Dark Byte" Heijnen.
Cheat Engine (CE) é uma ótima ferramenta para observar e modificar o espaço de memória de outros processos. Além dessa facilidade básica , o CE tem mais recursos especiais, como visualizar a memória desmontada de um processo e injetar código em outros processos.
(o valor real desse projeto é que você pode baixar o código-fonte -Delphi- e ver como esses mecanismos foram implementados - eu fiz isso há muitos anos: o)
fonte
Um bom artigo sobre este mesmo tópico pode ser encontrado em Uninformed . Ele cobre a reversão do Campo Minado (como uma introdução aos aplicativos Win32 de engenharia reversa) em grande detalhe e é um recurso muito bom.
fonte
Este site pode ser mais útil:
http://www.subversity.net/reversing/hacking-minesweeper
A maneira geral de fazer isso é:
Em resposta ao Bounty
Bem, em uma segunda leitura, parece que você queria um guia sobre como usar um depurador como o WinDBG, em vez da questão usual de como fazer engenharia reversa. Já mostrei o site que informa os valores que você precisa pesquisar, então a pergunta é: como você pesquisa por isso?
Estou usando o Bloco de notas neste exemplo porque não tenho o Minesweeper instalado. Mas a ideia é a mesma.
Você digita
Pressione "?" E depois "s" para ver a ajuda.
Depois de encontrar o padrão de memória desejado, você pode pressionar alt + 5 para abrir o visualizador de memória para uma boa exibição.
Leva algum tempo para se acostumar com o WinDBG, mas é tão bom quanto qualquer outro depurador por aí.
fonte
Um bom ponto para iniciar o rastreamento no depurador seria com o mouse para cima. Portanto, encontre o procedimento da janela principal (acho que ferramentas como spyxx podem inspecionar as propriedades do Windows e o endereço do manipulador de eventos é uma delas). Entre nele e descubra onde ele trata os eventos do mouse - haverá uma mudança, se você puder reconhecê-lo no assembler (veja o valor de WM_XXX para mouse up em windows.h).
Coloque um ponto de interrupção lá e comece a intervir. Em algum momento entre o momento em que você soltou o botão do mouse e a atualização da tela, o victum acessará a estrutura de dados que você está procurando.
Seja paciente, tente identificar o que está sendo feito a qualquer momento, mas não se preocupe em examinar muito profundamente o código que você suspeita não ser interessante para seu objetivo atual. Pode levar várias execuções no depurador para acertá-lo.
O conhecimento do fluxo de trabalho de aplicativos win32 normais também ajuda.
fonte
As minas provavelmente serão armazenadas em algum tipo de matriz bidimensional. Isso significa que é uma matriz de ponteiros ou uma única matriz de booleanos no estilo C.
Sempre que o formulário recebe um evento de mouse-up, essa estrutura de dados é referenciada. O índice será calculado usando as coordenadas do mouse, provavelmente usando divisão inteira. Isso significa que você provavelmente deve procurar por uma
cmpinstrução ou semelhante, onde um dos operandos é calculado usando um deslocamento ex, ondexé o resultado de um cálculo envolvendo divisão inteira. O deslocamento será então o ponteiro para o início da estrutura de dados.fonte
É bastante razoável supor que as informações sobre as minas sejam dispostas de forma contígua na memória, pelo menos para as linhas (ou seja, é uma matriz 2D ou uma matriz de matrizes). Assim, eu tentaria abrir várias células adjacentes na mesma linha, fazer despejos de memória do processo à medida que avançava e, em seguida, compará-los e procurar por quaisquer alterações repetidas na mesma região de memória (ou seja, 1 byte alterado na primeira etapa, a próxima byte alterado para exatamente o mesmo valor na próxima etapa, etc).
Também existe a possibilidade de que seja uma matriz de bits empacotada (3 bits por mina devem ser suficientes para registrar todos os estados possíveis - fechado / aberto, meu / não-mina, sinalizado / não sinalizado), então eu ficaria atento a isso também ( os padrões também seriam repetíveis, embora mais difíceis de detectar). Mas não é uma estrutura conveniente para lidar, e não acho que o uso de memória tenha sido um gargalo para o Campo Minado, então é improvável que esse tipo de coisa seja usado.
fonte
Embora não seja estritamente uma "ferramenta de engenharia reversa", e mais um brinquedo que até um idiota como eu poderia usar, dê uma olhada no Cheat Engine . Isso torna um pouco mais fácil rastrear quais partes da memória foram alteradas, quando, e até mesmo fornece recursos para rastrear as partes alteradas da memória por meio de ponteiros (embora você provavelmente não precise disso). Um bom tutorial interativo está incluído.
fonte