Forem: !Ryan Gozlyngg

Engenharia Reversa Primeiro Contato - Parte 2

!Ryan Gozlyngg — Sat, 08 Jun 2024 02:29:20 +0000

DIABLO - ORiON_CrackMe1 +18

O tutorial é dedicado aos iniciantes em engenharia reversa, mas eu tentarei explicar, o máximo possível, alguns processos do Assembly e da arquitetura Intel x86, para que, até mesmo pessoas que nunca estudaram nada disso, possam acompanhar, e -se eu não falhar na clareza- entender os processos.
E aí, quem sabe, você não crie interesse por está área de estudos.

Caso não saiba usar o Debugger x64dbg, segue uma breve introdução: https://dev.to/ryan_gozlyngg/engenharia-reversa-primeiro-contato-parte-1-2gih

Esse tutorial consiste na quebra de um programa feito para isso.
É de nível extremamente básico, feito, justamente, para iniciantes na área da engenharia reversa.
"Quebra de software" quer dizer: fazer o programa se submeter à sua vontade!

Algumas notas estão presentes para auxiliar no entendimento de coisas que eu julgue que devem ser de conhecimento do leitor.

Lista de Conteúdo

Requisitos para total entendimento do tutorial a seguir

Termos utilizados durante o tutorial

Link para o programa CrackMe

Análise Estática
Examinando as strings do programa

Análise Dinâmica

Como o Code (input) é processado

TEST CL, CL

Registrador EFLAGS

O Processo de Tratamento do Input

Vamos rastrear a origem desse valor no topo da stack/pilha

Observando a stack

Retorno de Função

Observando a Função crackme1.46B828

Encontrando valores no Dump

Entrando na Função crackme1.46B828

Entendendo como chegamos ao resultado

Caso o salto não seja executado, as seguintes instruções são usadas

Resumindo a lógica da função

Saindo da função e obtendo o resultado definitivo

SETNE - Instrução que gera o resultado

Considerações Finais

Requisitos para total entendimento do tutorial a seguir

Conhecimento básico sobre segmentos de memória, principalmente sobre o segmento chamado stack/pilha
Conhecimento sobre bases numéricas
Conhecimento básico de programação em C/C++

Aqui eu espero poder mostrar a quebra desse software na forma de tutorial, usando partes do processo para compartilhar alguns conhecimentos úteis com aquele leitor que está iniciando, e ainda tem alguma dúvida, ou dificuldade, em entender algo específico.
Também é dedicado aos que desejam ver como esse tipo de coisa é feita.

No mais, é sempre bom ver como outras pessoas solucionam problemas, como a mente delas funciona em determinadas atividades, para, talvez, extrairmos alguma coisa para nós mesmos.

Se você já iniciou os estudos em engenharia reversa, tente quebrar esse software por sua conta primeiro, depois volte aqui para ler.

Termos utilizados durante o tutorial

Code, CODE ou code: nome da área de input; é o mesmo que "serial", "key", "senha" ou input. Nesse software, os desenvolvedores chamaram a área de input de Code.
Breakpoint: ponto de interrupção, ponto de parada.
Setar: ação de aplicar algo sobre alguma coisa: exemplo: "setar breakpoint" significa: aplicar, definir, introduzir um breakpoint em ou sobre determinada instrução.
Binário: refere-se a um programa, um executável.

Link para o programa CrackMe

Baixe aqui: https://github.com/ReversingID/Crackmes-Repository/tree/master
Encontre ele no path: Crackmes.DE\1-very_easy_for_newbies\windows\diablo
Nota: Usar ou não uma máquina virtual dedicada para rodar o software está a seu critério.

Análise Estática

Em resumo, "análise estática" é uma análise feita apenas com as informações contidas no próprio arquivo do programa, também chamado binário, obtidas independentemente da execução do programa.

Para saber em qual arquitetura o programa foi compilado, você pode usar o programa DIE - Detect It Easy:

O DIE é um programa muito poderoso, por hora, vamos ficar somente com essas informações da interface inicial. Recomendo que você se aprofunde no uso do DIE.

Na caixa de baixo, com grande destaque em vermelho, podemos ver algumas informações interessantes. "PE32" indica que o programa é um executável de 32 bits. Nas caixas menores, marcadas em vermelho, podemos ver também, o modo e a arquitetura.

Examinando as strings do programa

Você pode ver as strings contidas dentro do programa, usando o software que preferir (inclusive com DIE, clicando no botão "Strings", na interface inicial):

Não tem como examinarmos as strings, uma por uma, já que 3,750 strings depois, alguma coisa pode acabar passando batido...

As strings mais interessantes são as que o programador criou. Vamos dar uma olhada no local em que as variáveis globais e estáticas, inicializadas, são guardadas: data segment, ou .data.

Eu utilizei o programa IDA para acessar a seção de dados (.data) mencionada.
O IDA é um programa utilizado para análise estática de binários, ele é muito poderoso, possui várias funcionalidades, não vou falar muito sobre ele aqui, recomendo procurar mais sobre.

O IDA possui uma versão gratuita: https://hex-rays.com/ida-free/
Caso você nunca tenha usado o IDA, e mesmo assim baixou para testar aí, saiba que ele nos mostra várias mensagens ao carregarmos o binário nele, por hora não se preocupe, dê "ok" em tudo até chegar na tela principal. Caso queira se aprofundar, recomendo começar com alguma das muitas playlists de introdução ao IDA, encontradas no Youtube.

No IDA: SHIFT+F7 -> clique duas vezes em .data -> clique na aba Hex view -> vá descendo e observando a coluna lateral:

Estamos vendo a seção de dados dentro do programa, em hexadecimal, e a sua respectiva representação em ASCII, na coluna da direita (circulada em vermelho).

Dica: Aqui podemos separar as strings em um bloco de notas, e ir testando uma a uma no input do programa, já que é a coisa mais fácil a se fazer.

Se você fez isso, então já sabe a resposta.

Análise Dinâmica

A Análise Dinâmica consiste em observar e analisar o programa durante a execução.

Eu usei o debugger x64dbg aqui, e como de costume, a primeira coisa que faço é procurar pelas referências às strings.
Encontrando a string correta (nesse caso "Wrong Code! Try Again!") eu consigo observar as instruções que ocorrem antes dela ser usada na caixa de diálogo.
Seguindo essa string, eu chego ao momento em que ela é usada, e a partir desse local, eu posso buscar entender qual a lógica por trás da tomada de decisão, que julga se o nosso Input está correto ou não.

Abra o programa no x64dbg (não esqueça que o programa é de 32 bits, e precisa ser aberto no x32dbg.exe) e rode (apertando F9) o programa até ele abrir, e a janela com o input aparecer para você.
Geralmente o x64dbg tem alguns breakpoints iniciais, que só funcionam na primeira vez que o programa é rodado, então se o EIP -Instruction Pointer (ponteiro de instrução), responsável por dizer em qual instrução você está no momento (a setinha verde na lateral esquerda te mostra ele), estiver parado, continue clicando em F9 para rodar o programa até ele ser completamente carregado, e aí ele estará disponível para você usar (observe a barra de tarefas do Windows).

Com o programa já rodando, dentro do x64dbg:

Clique com o botão direito do mouse, no meio do debugger, na janela CPU
Vá em: "Pesquisar por" -> "All User Modules" -> "Referências String"

Você será direcionado para está janela. A anterior está ali em cima, em CPU.

Aqui vemos algumas strings que chamam atenção...
Se começamos por esse método, fazemos como anteriormente:

Pegamos as strings "diferenciadas", e as testamos como input, uma a uma.

Você já deve saber que isso vai dar certo, mas por questão de curiosidade, se isso não tivesse funcionado, prosseguiríamos da seguinte maneira:

Clique duas vezes na string "Wrong Code! Try Again!"

Você será direcionado para a instrução (onde ela é referida) que carrega ela na função (provavelmente a main), dentro da janela CPU.

Sete um breakpoint nela, clicando em F2
Abra a janela do programa e insira um code/input diferente do esperado, um errado qualquer.
Clicando em "Ok" o programa irá rodar até parar em seu breakpoint setado.
Agora vamos procurar pelo que decidiu que nossa resposta está errada, em outras palavras, procuramos entender como viemos parar na mensagem de erro.

Vamos fazer a engenharia reversa do programa, até descobrirmos o critério de "resposta certa" e "resposta errada".

Como o Code (input) é processado

Vamos rever os passos até aqui:*
1. Buscamos as referências de strings em todos os User Modules
2. Encontramos a string que aparece na caixa de diálogo ao errar o input
3. Setamos um breakpoint nela
4. Rodamos o programa depois de inserir um input qualquer

Subindo um pouco a partir do breakpoint (setado em "Wrong Code! try Again!"), vemos que há uma instrução test cl, cl, um pouco antes das instruções que nos mostram a mensagem de erro.

Se você observar a instrução em [004016D7], que é um salto condicional JE (Jump if Equal),
pula para crackme1.4016F6 se o resultado de TEST CL, CL for igual a 0, ela nos direciona para a outra mensagem: a mensagem de sucesso.
Basta você dar dois cliques na instrução je crackme.4016F6 que o programa te redireciona para esse endereço.
Com isso, sabemos que, se CL for zero, quer dizer que colocamos o input/code certo.

Agora nos fazemos uma pergunta: O que leva CL a ter o valor zero, ou mesmo o valor atual?

Nota: *Se você não entendeu nada desse trecho, leia a parte seguinte, **TEST CL, CL, com calma...

TEST CL, CL

Antes de tudo, o que significa a instrução TEST CL, CL?
Caso saiba, pule para "Respondendo à pergunta: O que leva CL a ter o valor zero?".

*Instrução TEST: o programa está testando se **CL é zero ou não ("ou não" é literalmente qualquer coisa diferente de zero, como, por exemplo, -1, 1, 90000, 0xABC, 0xFFFF, 6, etc.).

CL é a parte mais à direita do registrador ECX (ver imagem adiante).
Registradores são espaços de armazenamento dentro do processador.

TEST: instrução que compara dois operandos, no nosso caso, compara CL com ele mesmo.
Com "TEST" o programa performa uma operação bit a bit, (bitwise) chamada AND.
A operação AND é uma operação lógica, efetuada com binários.
Caso não saiba nada sobre operações lógicas, veja: https://imasters.com.br/desenvolvimento/conheca-os-operadores-bitwise-bit-bit

Vamos tentar entender essa operação bit a bit, ou bitwise, utilizada aqui.

**Nota:* aqui fica claro a importância de saber sobre as bases numéricas: você tem um dado da realidade, e tem várias maneiras de quantificá-lo. Nós temos razões culturais para usarmos as bases decimais para quantificar a maioria das coisas, por isso, ao nos referirmos, por exemplo, ao número dez, dizendo "temos aqui, dez árvores", sabemos exatamente a quantidade de um determinado dado da realidade; no exemplo, sabemos que temos dez árvores.*

Por razões, também culturais, agora, com a existência dos computadores, nós passamos a usar as bases hexadecimal, octal e binária, nessa área.
Sendo assim, podemos dizer que temos: 10 árvores, em decimal. 0xA árvores em Hexadecimal, 012 árvores, em Octal, 0b1010 árvores, em Binário.
A quantidade na realidade não mudou, apenas a forma de representá-la é que foi alterada.
Os sufixos utilizados aqui são uma convenção, utilizada na linguagem C, sendo ZERO (0) para octal, ZERO XIS (0x) para hexadecimal, ZERO BE (0b) para binário, e NADA DE SUFIXO para decimal.
Cada uma das bases têm sua razão de existir. Recomendo ler:

Primeiro, um exemplo da operação bitwise AND, com o número 7, que em binário é 0111:

    7 AND 7 ou TEST 7, 7

    0b0111
    0b0111
    ------
    0b0111

Operação AND: 0b1 AND 0b1 = 0b1
0b1 AND 0b0 = 0b0
Ela só resulta em 0b1 se ambos os operandos forem 0b1.
Se um dos operandos for 0b0, a operação resulta em 0b0.
No windows: abra sua calculadora, escolha o modo programador, e faça as contas.

Nota: O zero à esquerda não diz nada, nem precisaria ali estar. 0111 e 111 dão na mesma.
Você precisa saber sobre algumas convenções de tamanhos, chamadas WORD. DWORD e QWORD.
Observações: 1.essas WORDS são traduzidas como "palavra", eu não gosto dessa tradução, por isso não uso. Mas você pode ver materiais falando sobre "o tamanho da palavra".
2.O tamanho real a que cada WORD se refere pode mudar conforme o sistema operacional.
Leia: https://mentebinaria.gitbook.io/engenharia-reversa/numeros/o-byte

Sobre o zero aqui mostrado: -resumindo- um byte tem oito bits. O número sete, se representado segundo uma convenção, que pede que, todos os números sejam mostrados como BYTES, seria representado assim: 0000 0111. Viu? Oito bits (1 BYTE = 8 bits), em duas colunas, com quatro valores cada.
Por costume, valores que usam quatro bits ou menos, eu os represento como "0000".

Registrador EFLAGS

Nós temos também um registrador especial, chamado EFLAGS, que possui todas as flags usadas pelo sistema, cada uma com um propósito diferente, que por sua vez, serão emitidas em determinadas operações, com o fim de sinalizar alguma coisa (leia o manual da Intel, link abaixo). Não vou me estender na explicação.
Para saber mais sobre EFLAGS, confira essa parte do livro gratuito de Assembly: https://mentebinaria.gitbook.io/assembly/aprofundando-em-assembly/flags-do-processador

Agora nós precisamos saber que, nesse registrador, nós temos uma flag chamada ZeroFlag.
Essa flag, em conjunto com as instruções de comparação, cmp e test, e as instruções de salto condicional, serve para controle do fluxo de execução do programa.
Sobre as instruções de salto condicional, veja: http://unixwiz.net/techtips/x86-jumps.html

Nota: Baixe o manual da Intel. Lá tem todas as instruções listadas, com as condições necessárias para a sua execução (o nome é Jcc para todas as condições diferentes de JMP): https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html

É o primeiro link do site, apontado pela seta vermelha na imagem acima.

A operação TEST CL, CL resultando em 0, seta a ZeroFlag para 1: ZF=1.
E é isso que a combinação das instruções TEST e JE (Jump if equal) faz:

se(ZF==1) então Pule para a localização, se não, se(ZF==0) não pule
if(ZF==1) then Jump to location else if(ZF==0) don't jump

CL

ECX é um registrador de 32 bits, e podemos usar apenas "uma parte dele", "dividindo-o":

(OBS: ignore o RCX, que é o nome usado para registradores de 64 bits, os coloquei ali para que você saiba da existência dele).

Quando usamos um registrador como ECX, usamos TODO ele, nossos dados de 4 bytes
(4 bytes são 32 bits) ocupam todos os espaços -incluindo os 32 bits de ECX, os 16 bits de CX, os 8 bits de CH, e os 8 bits de CL.

Mantenha em mente que ECX é um corpo completo, e podemos usar uma parte específica dele, obrigando o computador a ler/escrever somente na parte desejada, sendo CX, CH ou CL.

"Curiosidade": antigamente existiam processadores de 16 bits, CH ficava com os 8 bits mais significantes e CL com os 8 bits menos significantes, e hoje em dia ainda é assim, só que os registradores possuem mais espaço; mais espaço, mais divisões.

Para saber mais sobre bits mais significantes e menos significantes (MSB e LSB),
acesse o link: https://www.morningstar.io/post/2016/12/25/midi-msb-and-lsb#:~:text=MSB%20stands%20for%20most%20significant,4%20bits%20would%20be%200011

CH e CL: o "C" é padrão para Counter (mas o registrador é de propósito geral, então pode ser usado para quase "qualquer coisa"), o H significa "High byte" e o L "Low byte"
(o E de ECX é de extended, lembra que era CX -16 bits? Ele foi "extendido" para 32 bits).
Mais sobre: https://en.wikipedia.org/wiki/IA-32

O Processo de Tratamento do Input

Se você já sabe o input/code certo, coloque um breakpoint na instrução test cl, cl, depois insira o input/code correto, rode o programa, e perceba como CL vai estar com o valor 0 durante o teste; inserindo um valor errado, ele vai estar com valor 1 nesse momento.
Assim temos a prova de que é realmente ali que acontece confirmação final do input inserido.

Mantenha o breakpoint na instrução test cl, cl, insira um input errado e rode novamente.

O registrado EFLAGS (circulado em vermelho, a direita) nos mostra que a ZeroFlag vai ser modificada na próxima operação através do traço vermelho abaixo de ZF.
Circulado em preto, temos o valor contido em CL, bem como vemos sublinhado em verde na coluna dos registradores.
Foi inserido um input/code errado, e a ZeroFlag será setada para 0, dizendo que não tivemos o resultado 0 na operação TEST. Dê um stepover e veja por si mesmo.

Perceba que antes de test cl, cl nós temos a instrução pop ecx.

A instrução pop pega o valor que está no topo da stack/pilha (visível no registrador ESP), e carrega para dentro do operando, que no nosso caso é o ECX.

Nota: Não se esqueça de que o registrador **ESP* contém o endereço do topo da stack/pilha, e dentro desse endereço há um valor, e é ele que o pop "joga" para dentro de ECX.*

Breakpoint na Instrução pop ecx, inserimos um input errado, clicamos em "OK":

Nesse momento, o topo da nossa stack/pilha está assim (o input foi "AAA", que é errado):

Como o code/input não é o correto, o topo da stack está com 1.
(Se você já tem o code/input correto, como mencionado anteriormente, insira-o, e veja que, ao chegar nesse ponto, a stack/pilha está com o valor 0 no topo). Preste atenção no endereço do topo da stack/pilha, é ele que, mais tarde, vai nos levar até a função que dita se o input/code está certo ou errado.

Apenas o bit menos significativo de ECX, CL, é usado para a operação seguinte.
Com isso, na operação test cl, cl (é o mesmo que test 1, 1) temos o resultado 1, a ZeroFlag não é setada (ZF=0), então o programa não pula para crackme1.4016F6.

Vamos rastrear a origem desse valor no topo da stack

Como já vimos que é o valor, zero ou um, que está no topo da pilha, no momento do pop ecx, que determina o nosso sucesso ou erro, a depender do input, vamos agora tentar encontra a origem desse número.
Os valores que se encontram na stack/pilha, durante o breakpoint em pop ecx, têm origem em alguma operação da função atual.

As instruções responsáveis por lidar com valores da stack/pilha, são POP e PUSH.
POP: Carrega o valor do topo da pilha para o local especificado pelo operando de destino (ou opcode explícito) e, em seguida, incrementa o ponteiro da stack/pilha (ESP).
PUSH: Decrementa o ponteiro da stack/pilha (ESP) e armazena o operando de origem no topo da pilha.
Não deixe de consultar o manual da Intel para saber mais!

Lembre-se que o valor retornado por uma função é "guardado" no registrador EAX.

Nota: Aqui eu assumo que você já leu o primeiro tutorial, relacionado ao x64dbg, onde eu explico brevemente as funções em Assembly de x86. Novamente colocarei o link aqui: https://dev.to/ryan_gozlyngg/engenharia-reversa-primeiro-contato-parte-1-2gih

Segue o passo a passo efetuado:

Setamos um breakpoint nas três instruções call mais próximas ao test cl, cl.
Execute o programa novamente, até que ele chegue no breakpoint. Para fazer isso, basta dar um "Run" (atalho: F9), para ele sair dos breakpoints e pedir o input novamente.
Insira uma mensagem ERRADA no input/code. Clique em "Ok" para continuar.
Dê um step over com F8 até o EIP passar da instrução call, e verifique registrador EAX.
Verificamos se o valor contido em EAX é colocado no topo da stack/pilha (geralmente com a instrução push eax).

MUITA ATENÇÃO NO 6° PASSO: o endereço do topo da stack/pilha, em ESP, precisa ser 0x19EFDC imediatamente depois da instrução call. Isso porque, no momento do pop ecx em xxxxx, o endereço (da stack/pilha) 0x19EFD8 é que está com o nosso valor (0 ou 1) para o test cl, cl, e agora estamos assumindo que esse valor foi guardado na stack/pilha via instrução PUSH, a qual decrementa o endereço de ESP, e se você leu a documentação da Intel, sabe que ESP é decrementado por 4. Logo 0x19EFDC - 4 = 0x19EFD8.

(O manual nos diz: The operand size (16, 32, or 64 bits) determines the amount by which the stack pointer is decremented (2, 4 or 8). No nosso caso, como veremos logo, o operado é EAX, logo 32 bits, decrementado por 4).

Nota: Setando Breakpoint - alguns detalhes:

Como você já sabe, setamos um breakpoint em uma instrução, dentro do x64dbg, com a tecla **F2:

Selecione a linha desejada, e aperte **F2, a "bolinha" no canto esquerdo ficará **vermelha.
Se você clicar em cima dessa "bolinha", a "bolinha" ficará com verde, desabilitando o breakpoint.
Clicando na "bolinha" uma terceira vez, você removerá o breakpoint.

Nota: Ao clicar duas vezes em uma instrução call, ou dar um **step in* com o EIP nela (lembre da "setinha" na esquerda, que aponta para onde está o EIP), você vai entrar, ser direcionado, até o código dessa função.*
Como fazemos para voltar à instrução anterior? Para isso usamos o seguinte atalho: -

Observando a stack

Ao efetuar os passos acima...

Na imagem, você pode ver que eu inseri "AAA" como code/input, e por estar errado, precisamos ver o "1" no topo da stack/pilha ao passarmos por está call, no endereço que buscamos.
Observe as instruções. Na imagem, paramos antes da função ser executada.
Executamos um stepover (F8).

Podemos ver que no topo da stack/pilha temos o endereço desejado, e no campo das instruções temos push eax, que decrementará o nosso ESP, colocando o valor "1" de EAX no topo da stack/pilha.

Bem como estávamos procurando!

Retorno de Função

Um breve exemplo de um programa em C comentando o comportamento do código quando em Assembly de x86, para reforçar que o valor de retorno de uma função, em programas x86, é passado para EAX (na grande maioria dos casos, lembre-se das calling conventions).

// programa em C

/* Função SOMA: soma dois numeros a + b e retorna resultado */
int soma(int a, int b){
   int resposta_da_soma;

   resposta_da_soma = a + b;

   return resposta_da_soma; // esse valor é retornado em EAX
}

/* Função principal Main */
int main(){
   int a = 2;
   int b = 3;
   int resultado;

   // chama função com soma de dois valores 
   // aqui será uma call: call soma.endereço
   resultado = soma(a, b).

  // Aqui dentro da main, nesse momento teremos em EAX o número 5
}

Observando a Função crackme1.46B828

Antes de entrarmos na função, vamos ver os argumentos que são passados para ela.
Eu não vou explicar como as Calling Conventions funcionam, e é esse conhecimento que vai lhe ajudar a entender como os argumentos são passados para funções. Sim, existe mais de uma maneira de passar argumentos para funções em Assembly.
Para entender melhor sobre elas, acesse os links: https://mentebinaria.gitbook.io/assembly/programando-junto-com-c/convencoes-de-chamada-no-windows
https://en.wikipedia.org/wiki/X86_calling_conventions

Em resumo, as convenções de chamada (calling conventions) ditam como os argumentos de uma função vão ser passados a ela. Aqui nós podemos ver que antes da função ser chamada, o endereço de algo que está em [ebp-10] é carregado em EDX, e também vemos que o que está no topo da stack é colocado dentro de EAX.

Vamos ver, brevemente, o que essas funções, lea e pop estão fazendo:

lea - Load Efective Address: Carrega o endereço de qualquer coisa que está em [ebp-10] e guarda em EDX. Para entender [ebp-10], segue o link: https://mentebinaria.gitbook.io/assembly/a-base/enderecamento

pop - Pega oque está no TOPO da stack/pilha e guarda no operando, aqui é guardado em EAX, e em seguida incrementa o topo da stack/pilha.

Os argumentos foram passados através dos registradores EAX e EDX.
Entrando na função isso vai ficar claro.

Encontrando valores no Dump

Vamos ver rapidamente como rastreamos valores no x64dbg.
(Algo como [ebp-10] é carregado em EDX, basta um step-over para executar a instrução, e aí verificamos oque é que foi carregado em EDX, muito mais simples)...

Vamos ver quais valores se encontram em [ebp-10], e no topo da stack nessa hora:

Você já deve saber buscar esse valor no dump. Botão direito do mouse na instrução desejada, etc.(basta fazer como na imagem acima).

Encontre o valor desejado, que no caso é [ebp-10].

Agora vamos ao topo da stack/pilha:

Perceba que o topo da stack/pilha (em ESP) é sempre destacado em verde na Janela da Stack.
Vamos ver os valores carregados nos registradores:

Perceba que EDX tem um comentário que nos diz que o valor 0x0019F02C é um endereço para a string "***vErYeAsY***". Sabemos que é um endereço pelo símbolo "&".
Você pode segui-lo no dump e confirmar isso.

Em EAX temos o valor 0x0019F030, e para sabermos oque tem lá, podemos segui-lo no dump.

Perceba o valor que se encontra aqui. Parece outro endereço.
Podemos tentar seguir ele no dump também.

Chegamos nesse lugar. Observe que é aqui que se encontra o nosso code/input.
0x41 é o mesmo que o char 'A'. Cada 0x41 é um byte, você tem ali a seguinte string:

 "AAA\0"

Os três caracteres 'A', mais o null terminator \0, que indica o fim da string.
Confira: https://man7.org/linux/man-pages/man7/ascii.7.html

Então é isso, essa função está recebendo os endereços das duas strings como argumento.
Nos perguntamos: Será que ela vai comparar a nossa string "AAA" com essa string diferente aí??? E então testamos a string "***vErYeAsY***" como code/input.
E então é isso, funcionou!

Entrando na Função crackme1.46B828

Para entrar na função utilize o STEP-INTO (F7).

Dentro da função:

Perceba que aqui dentro, a função pega os argumentos, que são endereços, e os "desreferencía", fazendo com que os valores reais dentro daqueles endereços sejam guardados agora em EAX e EDX. Portanto, depois dessas operações MOV, os nossos registradores conterão os endereços diretos para nossas strings puras (perceba que antes disso nós temos um endereço para um endereço).

Observação: geralmente as funções chamam outras funções, que chamam outras funções, e chega em um nível em que você deve se perguntar: vale mesmo apena entrar em todas essas funções? Será que estou no caminho certo?

O que me fez perceber que estava no caminho certo aqui, foi a instrução que vem depois da call crackme1.460C48, a instrução setne al (sobre ela mais a frente).
AL é a parte "mais baixa" de EAX, sabemos que ele contém o retorno da função após a execução dela. E a operação que é feita com AL nos dá o retorno "1" que buscamos.

Por isso achei que valia apena continuar entrando nas funções.
Como aqui o programa já foi quebrado, e o desafio já foi vencido, eu estava motivado apenas por pura curiosidade de entender como o programa funciona, então achei que valia continuar com a busca.

Vamos para essa outra função agora.

Entendendo como chegamos ao resultado

Vou expor o processo de maneira linear (atenção: não vou expor o processo todo devido ao tamanho que o texto ficaria, vou focar nos pontos mais importantes para esse exemplo).

Nota: antes de tudo, perceba que, conforme o tamanho da nossa string digitada no input, o programa faz um caminho diferente dentro dessa função, já que ele compara alguns caracteres por vez. Sendo assim, quanto maior a nossa string, mais testes serão feitos.
No teste abaixo foi utilizado uma string de três caracteres: "AAA".

Acompanhe parte do processo da função 0x00460C48, começando pela comparação:

Passando do prólogo da função nós temos:

1.cmp eax, edx

Compara os endereços das duas strings.
A instrução CMP faz uma subtração: eax - edx. A diferença é que aqui o resultado não é salvo, e os operandos permanecem os mesmos.
Perceba que como os endereços estão sendo comparados, a próxima instrução, que é um salto "pule se for igual", não acontece.

2.test esi, esi

Verificando se o code/input não está vazio, caso esteja, ele pula para o fim da função e termina retornando 1.

3.test edi, edi

Verificando se a string com o code/input correto, passada pelo programador, não está vazia.

4.mov eax, dword ptr ds:[esi+4]
mov edx, dword ptr ds:[edi+4]
EAX recebe o tamanho da string que passamos para o code/input
edx recebe o tamanho da string que o programador passou para a função.
O tamanho das strings foi calculado em outra função.

5.sub eax, edx

subtrai EDX de EAX. A string correta tem o tamanho de 14 bytes, em hexa são 0xE.
A conta:
COM O INPUT "AAA": 3 - 14 = -11 ou 0xFFFFFFF5
COM O INPUT CORRETO: 14 - 14 = 0

O resultado é guardado em EAX.

Se ambos estiverem com o valor de 14 bytes, sendo a string correta ou não, a operação sub eax, edx resultaria em ZeroFlag = 1, e CarryFlag = 0.
Lembre-se que se uma operação resultar em zero, a ZeroFlag é setada, recebendo o valor "1".

6.ja crackme1.460C6B

JA - Jump if above, pula se as flags CF e ZF forem ambas iguais a 0.
Em outras palavras, o salto só será executado caso a nossa string seja ==maior== que a string do programador.
Com a nossa string sendo maior que a string do programador, a CarryFlag não é setada, porque não temos um resultado negativo, e a ZeroFlag não é setada, porque a operação não resulta em zero.

CF ou Carray Flag: Caso a operação aritmética precise utilizar o bit mais significante (MSB - que é o bit mais à esquerda) para guardar o resultado, a CF é setada para "1".

O bit mais a esquerda é usado quando precisamos representar um número com sinal, um número negativo.

Como o resultado da operação com a string menor "AAA" seta a Carry Flag, o programa não executa o salto. Já com a string correta, ele executa o salto.

Resumindo:
Com Uma ==String Menor==: [CarryFlag é setada e o salto não é executado]
Com Uma ==String de 14 bytes==: [ZeroFlag é setada e o salto não é executado]

Todo esse processo foi para ver se o code/input passado por nós é maior que a string do programador.

Caso o salto não seja executado, as seguintes instruções são usadas

7.add edx, eax

COM UMA STRING MENOR
Usei a string "AAA".
eax: 0xFFFFFFF5 - no caso de "AAA" (ou qualquer string de três bytes)
edx: 0xE
Cálculo: 0xE + 0xFFFFFFF5 = 00000003 (Resultado vem com o MSB setado: 100000003)

COM UMA STRING DE 14 BYTES
eax: 0 - resultado da subtração de 14 - 14
edx: 0xE - tamanho da string em hexadecimal (0xE = 14)
Cálculo: 0xE + 0 = 0xE

Aqui estamos restaurando o número de bytes da nossa string para EDX.

O resultado é guardado em EDX.
E em seguida o resultado é guardado na stack com push edx.

8.shr edx, 2

Aqui o programa usa a instrução SHR, com EDX e o número 2.
SHR é usada para mover os bits de EDX duas casas para a direita.
Para cada bit movido para a direita, um zero é adicionado à esquerda.

EXEMPLO COM UMA STRING DE 14 BYTES:

EDX está com o valor 0xE ou 14.
14 em binário é: 1110
Agora vamos mover os bits para a direita duas vezes:

1110
0111 -> 1.movemos um bit para a direita e adicionamos um zero à esquerda
0011 -> 2.movemos um bit para a direita e adicionamos um zero à esquerda

Agora nós ficamos com o resultado 0011 que é 3 (três é representado da mesma forma em hexadecimal e em decimal).

Ao terminar a instrução, aqui temos EDX = 3.

EXEMPLO COM UMA STRING DE 3 BYTES:

EDX está com o valor 3.
3 em binário é: 0011
Agora vamos mover os bits para a direita duas vezes:

0011
0001 -> 1.movemos um bit para a direita e adicionamos um zero à esquerda
0000 -> 2.movemos um bit para a direita e adicionamos um zero à esquerda

Agora nós ficamos com o resultado 0000 que é 0 (zero é representado da mesma forma em hexadecimal e em decimal).

Ao terminar a instrução, aqui temos EDX = 0.

9.je
se shr edx, 2 == 0 (Testando para ver se a operação resultou em zero)
a operação serve para o programa decidir qual caminho tomar baseado no tamanho da string que nós passamos para ele.
Se for uma muito pequena, ele vai pular para uma comparação de um único byte, o mais a direita.
Se a nossa string tiver um tamanho parecido com a correta, ele compara os primeiros 4 bytes,
e assim o programa prossegue, sempre se baseando no tamanho da nossa string.

Aqui segue os resultados para strings de 0 bytes até as de 14 bytes:

Perceba que as strings de 14, 13 e 12 bytes resultam em 3, forçando a função a ir pelo mesmo caminho, até detectar a divergência de tamanho.

Resumindo a lógica da função

Em resumo, você pode entender 100% da lógica sendo usada em qualquer função, mas se você não quer gastar todo o seu tempo com isso, pode começar a pegar padrões de comportamento para todos os tipos de dados processadas, no nosso caso, as strings.

Aqui não vou mostrar o que cada uma das instruções seguintes faz, isso vai deixar esse tutorial mais maçante e longo ainda...

Mas para quem quer saber oque se passa depois do já mencionado, dentro da função:
Perceba a série de saltos (jmp e jcc) e comparações (test e cmp).
A função está percorrendo ambas as strings e comparando os bytes.
A ordem da comparação varia conforme o tamanho da string enviada.

Bom, sabemos que a função vai retornar um valor dentro de EAX.

Com nossa string de três caracteres, ao fim da função, perceba que o valor em EAX é quase o mesmo que temos após a instrução sub eax, edx do passo cinco desse tutorial na parte intitulada "Entendendo como chegamos ao resultado".

Que tipo de alteração ele sofreu?

Vamos até a instrução mencionada (sub eax, edx), e a partir dela, seguimos com a atenção fixada em EAX, uma instrução por vez, com o step-over.

Se você fez isso, percebeu que o valor se mantém o mesmo em EAX até chegar em uma instrução que soma EAX com ele mesmo desde então.
(Mas lembre-se que o percurso depende do tamanho da string que usamos no code/input).

Após isso, o programa pula direto para a parte final da função com um salto obrigatório jmp.
EAX não sofre mais nenhuma alteração, e voltamos a função anterior.

Saindo da função e obtendo o resultado definitivo

Agora que você já tem uma noção de como o resultado retornado é formado, vamos ver oque é que nos dá o resultado definitivo para a comparação final.

Sabemos que a comparação final é, ou com o valor "1" ou com o valor "0".

A função em que entramos é a seguinte crackme1.46B828:

Já vimos oque acontece na função chamada em call crackme1.460C48, e retornamos na instrução setne al.

SETNE - Instrução que gera o resultado

setne - Set byte if not equal (ZF=0): essa instrução vai mudar o operando (no nosso caso o AL) para 0 ou 1, dependendo do status da ZeroFlag.

Como vimos antes, o caminho tomado pela instrução anterior, que retorna nosso valor em EAX, depende do tamanho da string enviada. Basta seguir o fluxo da função até ela tomar um salto para o final da instrução, e depois voltar a última instrução de comparação.

Para voltar para trás, e seguir esse fluxo, basta usar o atalho - (traço).
Assim vemos onde é que a ZeroFlag é setada.

Vamos seguir o caso da string "AAA":

A função nos faz saltar para o final, antes da instrução de retorno RET.
Usamos o atalho até voltarmos ao local com uma instrução de comparação.

Voltando, vemos o local do salto, e em cima dele, a última instrução de comparação, que está comparando o byte mais à direita da nossa string com a do programador.
Como o resultado é diferente, nós não temos a ZeroFlag setada.

Sabendo que a ZeroFlag não foi setada, nós também sabemos que a instrução setne al irá colocar o valor "1" na parte mais baixa (mais a direita) do nosso registrador EAX.

Após a execução de setne al, EAX fica com o seguinte valor: 0xFFFFFF01, e para termos apenas o valor setado por setne em EAX, a instrução and eax, 1 é performada.

Como "1" é representado como 0x00000001 e EAX é 0xFFFFFF01, somente o primeiro byte, mais a direita vai ter o valo "1", caso não seja "0", e qualquer outro byte vai ser mudado para zero. Lembra, operação AND só resulta em "1" se ambos os bits forem "1", e é por isso que, com a string correta, AL é setado para zero, e essa operação AND resulta em zero.

Considerações Finais

Espero que você tenha conseguido seguir e entender até aqui.
Espero que tenha pegado o "espirito" da coisa, e se for o caso, que tenha aumentado a sua curiosidade e interesse por esse tipo de conhecimento.

Para iniciar de verdade na engenharia reversa, eu recomendo começar pela seguinte playlist:

CERO - Curso de Engenharia Reversa Online por Mente Binária:

Curso de engenharia reversa em português 100% gratuito.

https://youtube.com/playlist?list=PLIfZMtpPYFP6zLKlnyAeWY1I85VpyshAA&si=3wYZb0E7iHaAFaMm

Engenharia Reversa: Primeiro Contato - Parte 1

!Ryan Gozlyngg — Sun, 17 Mar 2024 15:22:02 +0000

Você vai praticar engenharia reversa pela primeira vez.
"Engenharia reversa", na área de T.I. refere-se à engenharia reversa de software, que, a grosso modo, é a prática de entender o funcionamento de um software alheio, "nos mínimos detalhes".

Esse tutorial é uma breve introdução ao uso do debugger x64dbg, que é pré-requisito para o próximo tutorial.

Esse tutorial foi escrito para os iniciantes, o intuito é lhe preparar para o próximo tutorial: Debugando um programa crackme; observe que um é complemento do outro.
Programas "crackme" são softwares com algum tipo de desafio, como, por exemplo, descobrir uma senha de acesso ao próprio crackme.

O maior objetivo disso tudo, é mostrar um pouco desse mundo para pessoas que têm interesse em "baixo nível", mas não sabem se "isso é para elas".
Quero lhe ajudar a ter o "primeiro gostinho" desse mundo...

Lista de Conteúdo

O que é um Debugger
Sobre a Nomenclatura "x64dbg"
Antes de começar
Baixando o x64dbg
Abrindo o x64dbg
Mapeando as partes mais usadas da Interface Gráfica
- Botões de controle do Debugger
- Atalhos para Funcionalidades
- Janelas mais usadas
- Mapeando a janela CPU
  - Coluna de Endereços
  - Coluna de Opcodes
  - Coluna de Instruções Assembly
  - Coluna de Comentários
  - Coluna de Registradores
  - Stack
  - Dump de memória
  - Status do programa Debugado
Rodando Primeiro Programa no x64dbg
- Encontrando Strings
- Noções básicas sobre Funções em Assembly
- Atalhos úteis
Final: Considerações e Recomendações
- Caso esteja procurando obter os fundamentos da computação, eu sugiro que você confira os links desta área

O que é um Debugger

Debugger é um software que serve para "debugar" e testar programas.
"Debugar" é o processo de procurar bugs.
Bugs são erros ou problemas em um software.
E "testar", aqui, se define como "fazer oque quisermos com o software".

O Debugger lhe fornece acesso ao programa compilado.
Em um debugger, você vai ter acesso aos seguintes recursos:

Valores das suas variáveis em memória - Mapa de memória
Suas linhas de código transformadas em instruções Assembly
Módulos (dll's e lib's) usados
Threads e Handles

Sobre a Nomenclatura "x64dbg"

Não se confunda: o nome do programa como um todo é x64dbg.
Ele possui dois APLICATIVOS que são chamados x64dbg e x32dbg.

Você sempre deve saber qual dos dois deve usar para debugar um programa em específico, dependendo da plataforma para a qual o programa foi compilado:

o aplicativo chamado x64dbg serve para debugar programas de 64 bits.
o aplicativo chamado x32dbg serve para debugar programas de 32 bits.

Caso você não saiba se o seu programa é de 32-bits ou se é de 64-bits, abra o link:
Como saber se um programa é 32 ou 64 bits no windows.

No tutorial a seguir, quando eu disser "x64dbg", eu estarei me referindo ao programa como um todo, e não ao aplicativo específico.

Antes de começar

Vou trabalhar apenas com Assembly de x86_x64:

Assembly não é uma linguagem de programação comum, como C, que você aprende e sai criando programas para "qualquer coisa": há diversos processadores, e cada um possui uma arquitetura, que vai dizer como as instruções são nomeadas e como vão funcionar, que dita o nome e funcionamento dos registradores, etc.
Mais sobre: ISA-Instruction Set Architecture
Não é esperado nenhum conhecimento prévio sobre debuggers ou Assembly.
É esperado conhecimento básico em programação, e processo de compilação.
Conhecimento sobre fundamentos da computação lhe ajudarão a entender melhor o que se passa aqui. (Nota: Você pode usar um debugger para reforçar os estudos dos fundamentos da computação, já que, dessa forma, irá ver as coisas acontecendo na prática).
O básico sobre sistemas numéricos é esperado.

Espero lhe dar um overview de como é usar um debugger, mas tenha em mente que tópicos extremamente importantes estão sendo deixados de lado para não lhe "inundar" de informações no início. Entenda isso como um "Quick Overview".

Se estiver procurando obter os fundamentos da computação, confira os links deixados na parte final.

Baixando o x64dbg

Vá ao site oficial: x64dbg.com

Clique em Download

Você será redirecionado ao site da Sourceforge. Clique em Download Latest Version

"Instalando" o x64dbg

Extraia o arquivo zip. Você pode criar uma pasta em qualquer lugar para armazená-lo.

Abra a pasta extraída

Vá em: release/x32, ache o aplicativo x32dbg e crie um atalho na área de trabalho

Vá em: release/x64, ache o aplicativo x64dbg e crie um atalho na área de trabalho

Abrindo o x64dbg

Para abrir qualquer programa no x64dbg:

Abra o x64dbg
Clique em Arquivo -> Abrir (ou clique em F3)
Alternativa: Arraste o programa para um dos atalhos do x64dbg
Para abrir um programa que está rodando, abra o debuger, clique em Arquivo -> Anexar/Attach e escolha o programa.

Mapeando as partes mais usadas da Interface Gráfica

* Guie-se pelas cores.

Botões de controle do Debugger

Área com os botões de controle do Debugger. Clique em Debug (ao lado de Exibir) para ver todos os nomes e atalhos dos botões nessa seção.

Ícones, da esquerda para a direita:
1. Abrir Arquivo
2. Recarregar programa
3. Fechar programa que está carregado
4. Rodar programa carregado
5. Pausar programa carregado
6. Step Into: anda, de instrução em instrução, e entra nas instruções call: instruções call chamam outras funções. "Entrar nelas" quer dizer ir até a função.
7. Step Over: anda, de instrução em instrução, e NÃO entra nas instruções call

Não vou comentar sobre os outros botões, para saber sobre eles:
https://help.x64dbg.com/en/latest/gui/views/Trace.html
https://help.x64dbg.com/en/latest/introduction/ConditionalTracing.html

Atalhos para Funcionalidades

Atalhos para algumas funcionalidades do x64dbg (não entrarei em detalhes).

Vou mencionar apenas o quinto, da esquerda para a direita, que é o ícone de favoritos.
Quando você quiser salvar alguma localização de instrução, use CTRL+D, que a instrução selecionada será salva nos favoritos. Clique no atalho mencionado para ser direcionado aos favoritos.

Janelas mais usadas

Nessa parte do x64dbg, você tem todas as janelas de funcionalidades do programa.

Só marquei na caixa amarela as que eu vou estar comentando. Para você começar a usar o programa, acredito que só precisa dessas janelas. Mas não deixe de aprender todas, caso queira prosseguir nos estudos.

Clicando em exibir (ao lado de Arquivo, canto superior esquerdo) você pode habilitar as janelas que não estiverem aparecendo, e também pode ver os atalhos para cada uma delas.
Na imagem acima, se encontra a janela CPU, que será comentada no final desta parte sobre janelas.

Janela Breakpoints: breakpoints são pontos de parada, locais em que o programa vai parar obrigatoriamente. Logo falaremos mais sobre breakpoints. E nessa janela você tem acesso aos breakpoints que estão setados no programa todo. Aqui você pode manipular breakpoints, habilitando-os, desabilitando-os, ou mesmo removendo-os, e é até possível editá-los. Clicando em um deles, você será direcionado até o local em que ele está setado, na janela CPU.

Janela de Símbolos (Modules): essa é uma janela de extrema importância para algumas atividades, já que ela nos mostra os módulos importados pelo programa, inclusive o módulo do próprio programa.

Janela Referências: Aqui temos as referências, que procuramos da seguinte maneira: Dentro da janela CPU, clique com o botão direito do mouse, bem no final você vai encontrar "Pesquisar por" e "Encontrar referência aos": Os resultados das pesquisas feitas por essas opções serão mostrados na janela **Referências**.

Janela Mapa de Memória: Como o nome diz, é um mapa da memória do programa todo. Você pode ver onde um determinado endereço se encontra da seguinte maneira:

Dentro da janela CPU, selecione um endereço desejado (sobre endereços, comentarei mais a frente)

Dentro da janela CPU, clique com o botão direito do mouse em cima do endereço desejado

Clique em "Seguir no Mapa da Memória":
Você verá as informações a respeito do endereço selecionado no mapa de memória.

Janela CPU: Nos mostra tudo o que estamos vendo na imagem "mapeada" acima, e por essa ser a janela principal, todos os comentários às marcações com cores a seguir, serão sobre ela.

Mapeando a janela CPU

Vamos passar a maior parte do tempo nessa janela, ela é a janela principal do x64dbg.

Coluna de Endereços

Na primeira coluna da grande área, nós temos os endereços de memória (endereços de memória virtual, Virtual Address - VA).
A marcação verde nos mostra qual a próxima instrução a ser executada. O destaque em dourado é uma instrução marcada como "favoritos" usando CTRL+D.
Para saber mais sobre endereços de memória: https://learn.microsoft.com/pt-br/windows/win32/memory/virtual-address-space

Coluna de Opcodes

Na segunda coluna da grande área, nós temos os Opcodes, que são códigos de operação, eles ditam uma operação a ser executada pelo processador (por isso do nome OPeration Code);
Aqui estão em hexadecimal. Cada opcode é usado para formar uma instrução Assembly. Os opcodes também são chamados de Código de Máquina, e isso é oque chamamos de Assembly.

Por exemplo, temos a instrução chamada add, que soma dois operandos.
Em Opcode ela é equivalente a um dos seguintes, dependendo do contexto (na imagem, coluna Opcode, lado esquerdo):

Isso é a tabela que nos mostra como a instrução add é montada em arquitetura Intel x86_x64.
Repare as colunas 64-bit Mode, para programas de 64 bits e Compat/Leg Mode para programas de 32 bits. Para saber mais, clique no link:
Manual da Intel para desenvolvedores.

Vamos ver qual opcode obtemos compilando um programa para um sistema de 64 bits:

// Programa em C
int main(){
   int primeiro_numero = 3;
   int segundo_numero = 2;
   int resultado_da_soma;

   resultado_da_soma = primeiro_numero + segundo_numero;

   return 0;
}

Repare na linha selecionada: o programa está com o opcode 03 /r.

Coluna de Instruções Assembly

Na terceira coluna da grande área, nós vemos as instruções Assembly. Falamos sobre elas anteriormente, na coluna dos Opcodes.

Coluna de Comentários

Na quarta coluna da grande área, temos a seção de comentários.

Podemos ter comentários automáticos, por exemplo, no caso de instruções que estão carregando uma string, vamos ter a própria string como comentário. Também podemos adicionar nossos comentários, basta clicar na tecla ; e escrever algo, ao terminar é só dar enter.

Coluna de Registradores

Aqui, no lado extremo direito, temos os registradores e seus conteúdos.

Os registradores são espaços de memória dentro do processador, e funcionam como variáveis temporárias.

Há registradores de propósito geral, que sempre vão ser usados para coisas diversas:

Registradores de Propósito Geral x64:

RAX
RBX
RCX
RDX
RSI
RDI
R8, R9, R10, R11, R12, R13, R14 e R15. Em x64 temos esses oito registradores a mais.

Registradores de Propósito Geral x86:

Em teoria esses registradores podem ser usados para qualquer coisa, mas há situações em que RDI/EDI e RSI/ESI são usados de forma exclusiva por certas instruções.

Também há registradores que servem para armazenar coisas específicas.
Vou mencionar apenas os que considero mais importantes para o momento.
Para saber mais, não deixe de ler:
How many registers does an x86-64 cpu have

Registradores x86 (32 e 64)

Alguns Registradores de uso específico (na ordem: x64/x86):

RSP/ESP - Ponteiro para o topo da stack/pilha
RBP/EBP - Ponteiro para a base da stack/pilha
RIP - Ponteiro para a próxima instrução a ser executada. IP - Instruction Pointer (vai ser mostrado como RIP em x64, e EIP em x86). É por esse registrador que nós sabemos onde estamos dentro do programa, durante o fluxo de execução. Como ele tem o valor da próxima instrução a ser executada, estamos exatamente "um passo" atrás dele.

*Também deixei de mencionar os registradores que lidam com float's. Mais sobre: https://my.eng.utah.edu/~cs4400/sse-fp.pdf

Stack

Abaixo dos registradores, nós temos a Stack, também chamada de pilha (em pt-br).
A stack/pilha é um segmento de memória que opera com uma estrutura de dados de pilha (stack), por isso do nome.
Aqui nós temos os valores de nossas variáveis locais. Enquanto você estiver dentro de uma função, seus dados locais vão estar ali.

A coluna da esquerda representa o endereço da stack/pilha, e a coluna da direita nos mostra o valor armazenado naquele endereço.

A stack/pilha é uma estrutura de dados do tipo LIFO - Last In First Out, ou último a entrar, primeiro a sair. Todo mundo costuma usar o exemplo de uma pilha de pratos para explicar a stack: em uma pilha de pratos, qual prato você tira PRIMEIRO? O último empilhado, ou o primeiro, que deu início a pilha?
É lógico que, primeiro, você tira o que está no topo, LIFO...

Lembra dos registradores RSP e RBP? Então, é aqui que eles entram: RSP aponta para o topo da pilha, e RBP aponta para a base da pilha.
É assim que o layout de memória de uma função é delimitado e manipulado, através desses registradores.

E isso é que é chamado "stackframe", é o espaço de memória reservado para uma função.
Veremos um pouco mais sobre isso em "Noções básicas sobre funções em Assembly".

Dump de Memória

Ao lado esquerdo dos registradores, nós encontramos um dump da memória em hexadecimal.
Você pode clicar com o botão direito do mouse em qualquer instrução, e seguir tanto o endereço dela, quanto algum endereço que ela esteja operando. Também é possível fazer o mesmo nos registradores.

Voltando a imagem do Dump, a coluna mais a esquerda mostra o endereço respectivo aos dados hexadecimais nas quatro colunas seguintes (quatro colunas na configuração padrão).
Na última coluna, mais a direita, temos a representação ASCII dos dados em memória.

Também podemos alterar a visualização dos dados do dump: além de hexadecimal, ele nos mostra os dados como Inteiros e Floats. Basta clicar com o botão direito do mouse na área de dump e clicar em "Integers" ou em "Floats".

Na parte de cima nós temos vários dumps, para os quais você pode direcionar a visualização de algo que lhe interessar. Também temos outras funções, mas não vou mencioná-las aqui. Para saber mais, leia: Watch Control

Status do programa debugado

Aqui, no canto inferior esquerdo, nos é mostrado em que situação o programa debugado se encontra, como, por exemplo, se ele está em execução, ou pausado, e se estiver pausado, o motivo.

Rodando primeiro programa no x64dbg

Bom, agora que você já sabe como abrir o seu programa no x64dbg, vamos aprender mais algumas coisas antes de seguirmos para o próximo tutorial.
Abra qualquer programa com o x64dbg, de preferência um feito por você mesmo.

Em seguida, abra a janela (em vermelho) da seguinte maneira: Clique em Options -> Preferências
E aí desmarque a caixinha apontada pela seta, System Breakpoint. Assim você desativa alguns breakpoints "desnecessários" para nós agora (para saber mais sobre System Breakpoints: https://www.youtube.com/watch?v=vdyyg72tc2w).

Ao abrir o programa, ele vai ser mostrado na barra de tarefas somente quando for carregado. Eu estou abrindo um programa simples, ele já carrega a janela de primeira.

Se for um programa mais complexo, ele vai carregar outras coisas antes de poder desenhar a janela. Basta clicar em RUN (F9) até parar em um breakpoint: entry breakpoint, que você vê ao lado do status do programa:

Sempre acompanhe o status do programa na barra inferior, ao lado do PAUSE.

Vamos tentar encontrar nossas funções. Se o programa não foi "cuidadosamente estripado", achar a função principal, main, não é tão difícil.

Vá até a janela Símbolos, que possui nossos módulos, encontre o módulo principal (que possui o nome do próprio programa rodando), clique nela e seja direcionado para o início desse módulo:

Assim , se o programa não for extremamente complexo, você vai encontrar a main.

Dica: os programas compilados para x86, geralmente mantêm a função main no topo, então assim que o programa parar no entry breakpoint, vá ao topo das instruções que você encontrará a main.

Encontrando Strings

Outro modo de encontrar a main, é quando ela chama alguma string.
Para encontrar as strings dentro do programa é fácil:

na janela CPU, clique com o botão direito do mouse no meio da janela, vá até
Pesquisar Por -> All User Modules -> Referências String.

Carregando as strings na janela de referências, procure pela que você sabe que é usada na main, e aí clique nela. Você será redirecionado para o local em que ela aparece no programa, na janela CPU. O início da função, é o início da main, a nossa função principal, que o programador escreveu.

Noções básicas sobre funções em Assembly

Toda função em Assembly possui um prólogo e um epílogo.

Normalmente as funções possuem as seguintes instruções no início (o prólogo):

push ebp
mov ebp, esp

E a seguinte instrução no final (o epílogo):

ret

Lembre-se que as instruções em x64 utilizam os registradores rsp e rbp

No início, o programa salva o valor que está no registrador EBP/RBP com push ebp. Esse valor é o endereço da base da stack/pilha da função anterior; lembre-se que a stack/pilha possui os valores das variáveis locais, e que as variáveis locais são variáveis declaradas e/ou definidas dentro das funções (somente as variáveis definidas, isto é, variáveis com valores, vão ser colocadas na stack/pilha).

Após salvar o valor de EBP, um novo stackframe é iniciado; em outras palavras, um novo local ("local" se refere a um bloco de memória na stack) para guardar as variáveis dessa nova função é "delimitado". Isso é feito com mov ebp, esp.

Tenha em mente que, para cada nova função, um novo stackframe é mapeado e alocado para ela, assim, cada função lida somente com os valores das suas próprias variáveis.

Você vai precisar saber sobre calling conventions para entender como os argumentos são passados para as funções, eu não irei explicar isso aqui, então se quiser saber mais, não deixe de ler:
https://en.wikipedia.org/wiki/X86_calling_conventions
Calling Convention Stack Frame

Atalhos úteis

Clicando com o botão direito do mouse no meio da janela CPU, vá até "Ir Para", lá você terá acesso as seguintes funcionalidades (decore os atalhos):

Os atalho mais úteis de todos são o primeiro e o segundo:

RIP *: ele te direciona para onde o seu programa está no momento, seguindo o RIP.
Anterior -: Volta para a instrução executada anteriormente.

Final: Considerações e Recomendações

Não deixe de fazer o tutorial prático com o x64dbg [COLOCAR LINK QUANDO PRONTO].

Os debuggers são poderosos e úteis para as mais diversas atividades na área da computação. O x64dbg faz muitas coisas, várias delas eu deixei de mencionar aqui, como, por exemplo, alterar as instruções de um programa, para modificar sua funcionalidade.
Quanto mais você for estudando sobre tópicos de engenharia reversa, mais os debuggers se mostrarão úteis. Você irá se aprofundar nas diversas funcionalidades conforme a sua necessidade.

Um site muito bom para continuar praticando a leitura de Assembly é o seguinte: godbolt.org Selecione uma linguagem, como C ou C++, escolha um compilador, e comece os testes.

Caso esteja procurando obter os fundamentos da computação, eu sugiro que você confira os links desta área:

Guia de estudos: https://www.mentebinaria.com.br/studying-materials/basico-para-computacao/

Tutorial Gratuito de Assembly pt-br: https://github.com/andreluispy/assembly4noobs

Livro Gratuito de Assembly em pt-br: https://mentebinaria.gitbook.io/assembly/

Fundamentos da Engenharia Reversa pt-br: https://mentebinaria.gitbook.io/engenharia-reversa/

Curso de Engenharia Reversa Online (vídeo pt-br): https://www.youtube.com/playlist?list=PLIfZMtpPYFP6zLKlnyAeWY1I85VpyshAA

Livro Em Inglês para iniciantes em Engenharia Reversa en: https://beginners.re/