Program vs. Source-Code#

• Um programa geralmente se refere a uma sequencia de instrucoes enviadas a um computador para que ele execute algo;
• Um programa combinado com todos os outros recursos necessarios para sua execucao eh conhecido como codigo objeto;
• A palavra codigo-fonte eh reservada em geral para o codigo (de maquina ou de alto nivel) usado para criar o programa.

Overflow vs. Underflow#

• Calculos usando numeros em ponto flutuante podem gerar overflow e underflow se o algoritmo usado produzir um resultado que saida do intervalo aceitavel de valores;
• Por exemplo, se o resultado de um calculo eh um valor proximo de zero que nao pode ser expresso com precisao usando os bits disponiveis, ele gera o que chamamos de underflow.

CPU Benchmark#

• O desempenho da CPU eh determinado pela velocidade de clock da CPU e sua velocidade de execucao de operacoes;
• A velocidade do clock nos informa com que frequencia os circuitos logicos na ALU podem executar calculos, e a velocidade de execucao de operacoes nos informa o quao rapidamente a CPU pode executar calculos um apos o outro;
• Blocos de ALU de CPUs mais antigas funcionavam apenas com aritmetica inteira, por isso, o desempenho da CPU era medido em quantas instrucoes ela podia trazer em um segundo, o seu valor de MIPS (milhoes de instrucoes por segundo), em vez de quao rapidamente ela podia executar operacoes de calculo;
• Mas CPUs modernas tem hardware integrado especializado apenas para a finalidade de calculos com ponto flutuante e, por isso, recentemente a medida de desempenho preferia tornou-se a quantidade de operacoes em ponto flutuante que a CPU pode executar em um segundo, ou MFLOPS (milhoes de operacoes em ponto flutuante por segundo);
• Usa-se, para essa medicao, operacoes em ponto flutuante com 15 digitos significativos;
• As vezes usamos unidades diferentes de MFLOPS, como GFLOPS (gigaFlops) e TFLOPS (teraFLOPS).

Big Endian vs Little Endian#

• Define como bytes de um valor multibyte sao organizados na memoria, e faz referencia a primeira posicao desse valor, que pode receber o MSB (Most Significant Bit) ou o LSB (Least Significat Bit);
• No caso do MSB na primeira posicao, temos o Big Endian, que seria a ordem “natural” para leitura humana, usado em protocolos de rede e alguns RISC antigos;
• Ja quando temos o LSB na primeira posicao, temos o Little Endian, que pode ser interpretado como a leitura contraria a “natural” humana, usada pela maioria das CPUs modernas e arquiteturas x86 / x86_64 / ARM.

1
> 0x12345678
2

3
BE:
4
  +0   +1   +2   +3
5
  12   34   56   78
6

7
LE:
8
  +0   +1   +2   +3
9
  78   56   34   12

GOT Table and PLT Table#

• A GOT (Global Offset Table), eh uma tabela em memoria que guarda os enderecos reais das funcoes e variaveis dinamicas (majoritariamente simbolos definidos em shared objects) em tempo de execucao;
• A PLT (Procedure Linkage Table) eh um codigo stub (“duble” de uma funcao real) usado para chamar funcoes de bibliotecas dinamicas;
• A PLT consulta a GOT para saber onde saltar (mas nao logicamente), o que ela faz eh indirecionar o fluxo via ponteiro armazenado na GOT;
• Funcionamento:

1
> Primeira Chamada:
2
- Resolve o addr real via "dynamic linker".
3

4
main
5
 │
6
 │ call puts@plt
7
 ▼
8
.plt[puts]
9
 │
10
 │ jmp *puts@got        ← ponteiro ainda NÃO resolvido
11
 ▼
12
.got[puts] ──────────────┐
13
                         │ (aponta inicialmente para)
14
                         ▼
15
                    .plt[0]  (resolver stub)
16
                         │
17
                         │ push reloc_index
18
                         │ push link_map
19
                         │ jmp ld.so
20
                         ▼
21
                dynamic linker (ld-linux.so)
22
                         │
23
                         │ resolve símbolo "puts"
24
                         │ encontra puts em libc.so
25
                         │ escreve addr real em puts@got
26
                         ▼
27
                     puts (libc.so)
28

29
> Proximas Chamadas (sem linker no meio)
30
- Vao direto para o addr resolvido.
31

32
main
33
 │
34
 │ call puts@plt
35
 ▼
36
.plt[puts]
37
 │
38
 │ jmp *puts@got  ─────────────► puts (libc.so)

Schema#

1
+--------------------------------------+
2
|          General-purpose Registers   |
3
+--------------------------------------+
4
| EAX (32 bits)                        |
5
|  +----------------+                  |
6
|  | AX (16 bits)   |                  |
7
|  |  +----+----+   |                  |
8
|  |  | AH | AL |   | <- AH: 8 bits    |
9
|  |  +----+----+   |    AL: 8 bits    |
10
+--------------------+-----------------+
11
| EBX (32 bits)                        |
12
|  +----------------+                  |
13
|  | BX (16 bits)   |                  |
14
|  |  +----+----+   |                  |
15
|  |  | BH | BL |   | <- BH: 8 bits    |
16
|  |  +----+----+   |    BL: 8 bits    |
17
+--------------------+-----------------+
18
| ECX (32 bits)                        |
19
|  +----------------+                  |
20
|  | CX (16 bits)   |                  |
21
|  |  +----+----+   |                  |
22
|  |  | CH | CL |   | <- CH: 8 bits    |
23
|  |  +----+----+   |    CL: 8 bits    |
24
+--------------------+-----------------+
25
| EDX (32 bits)                        |
26
|  +----------------+                  |
27
|  | DX (16 bits)   |                  |
28
|  |  +----+----+   |                  |
29
|  |  | DH | DL |   | <- DH: 8 bits    |
30
|  |  +----+----+   |    DL: 8 bits    |
31
+--------------------------------------+
32

33
+--------------------------------------+
34
|         Special-purpose Registers    |
35
+--------------------------------------+
36
| ESP (Stack Pointer)  (32 bits)       |
37
+--------------------------------------+
38
| EBP (Base Pointer)   (32 bits)       |
39
+--------------------------------------+
40
| ESI (32 bits)                        |
41
+--------------------------------------+
42
| EDI (32 bits)                        |
43
+--------------------------------------+

8 bits Segments#

• Sempre que tratamos de um unico caractere temos um byte isolado (8 bits) e podemos usar os operadores desse segmento para realizar transformacoes;
• Essas transformacoes ocorrem nos segmentos de 8 bits dos registradores, como por exemplo, o al.

Flags (Flags Register)#

• Tambem chamado de FLAGS (16 bits), EFLAGS (32 bits) ou RFLAGS (64 bits);
• Guarda informacoes sobre o resultado da ultima operacao da CPU e controla certos comportamentos do processador;
• Nao armazena dados, e sim estados e condicoes, util para desvios;
• As principais flags sao:
  • ZF / Zero Flag / Flag-Z:
    • Indica se o acumulador eh zero;
    • Se a CPU nao tiver um modulo dedicado par afazer comparacoes, essa flag tambem pode ser o flag que reporta o resultado de um teste de comparacao (a Flag-EQ - outras flags podem ser implementadas na ULA, como Flag-GT e Flag-LT).
  • SF / Sinal Flag / Flag-S / Negative Flag / Flag-N:
    • Se o acumulador contem um numero, esse flag diz se o numero eh negativo ou positivo.
  • CF / Carry Flag / Flag-C:
    • Indica se houve carry / borrow em uma operacao sem sinal (unsigned);
    • Se preocupa com limites binarios, nao com valores positivos / negativos;
    • Pode-se chamar de unsigned overflow, pois esta ligada a “estourou os bits disponiveis?”, e nao sabe nada sobre numero negativo.
  • OF / Overflow Flag / Flag-OV:
    • Indica erro de magnitude em operacoes com sinal (signed), ou seja, se o resultado ultrapassou o intervalo designado;
    • Na soma, a flag eh ativada se, ao somar dois numeros do mesmo sinal, o resultado apresenta um sinal diferente, isso porque o bit MSB designa o sinal em operacoes signed;
    • Basicamente, mede o signed overflow, e esta ligado a mudanca inesperada de sinal e nao tem relacao com carry / borrow.
  • PF / Parity Flag:
    • Indica se o numero de bits 1 no resultado da ultima operacao eh par;
    • Usado principalmente em operacoes antigas de verificacao de erro (pense como se fosse um checksum a nivel de hardware) e no comportamento de algumas instrucoes especificas.
  • DF / Direction Flag:
    • Determina a direcao (frente ou tras) de avanco dos registradores SI e DI nas instrucoes de string.
  • IF / Interrupt Flag:
    • Controla se a CPU aceita interrupcoes mascaraveis (interrupcoes externas normais), que determina que tipos de interrupcoes ocorrerao;
    • Essa flag eh manipulada com instrucoes como CLI (Clear Interrupt Flag) e STI (Set Interrupt Flag).

Command Categories#

• Existem 3 categorias, sao elas:
  • Movimentacao de Dados:
    • mov;
    • movzx (move with zero-extended):
      • Os bits superiores do operador de destino sao preenchidos com zero.
    • push;
    • pop;
    • lea.
  • Logica Aritmetica:
    • add, inc;
    • sub, dec;
    • imul;
    • idiv;
    • div:
      • Divide pelo valor presente em eax;
      • Quociente vai para eax;
      • Resto vai para edx.
    • and, or, xor, not;
    • neg;
    • shl, shr;
      • sh eh o mesmo que shift;
      • E l eh left e r eh right.
  • Controle de Fluxo:
    • jmp (e suas variacoes);
    • cmp;
    • call, ret.

Absolute Addressing#

• Quando o valor do operando eh usado como o endereco efetivo (endereco no qual esta localizado o dado de destino da operacao);
• As vezes ele tambem eh chamado de direct addressing.

Relative Addressing#

• Enderecamento relativo eh quando o endereco efetivo resulta da soma do valor do operando e o contador do programa;
• Mais comumente usado para instrucoes do tipo jump;
• Uma vez que a distancia ate o endereco que desejamos apontar eh limitada pelo intervalo expresso pelo complemento de dois do numero de bits disponiveis no operando, o enderecamento relativo eh melhor usado para instrucoes de desvio condicional no programa e nao eh recomendado para saltos maiores no espaco de enderecos;
• Alem de usar o contador do programa como valor base para o endereco relativo, podemos usar o endereco em um registrador; chamamos enderecos desse tipo de enderecos relativos de registrador-xx.

Indirect Addressing#

• Usado quando o operando contem o endereco para algum registrador e esse registrador, por sua vez contem o endereco efetivo para nosso dado de destino;
• Podemos pensar nele como ponteiros da linguagem C, que trabalham com referencia e deferencia.

Address Modification#

• Processo de usar o valor armazenado em um registrador de modificacao para alterar um numero ou endereco;
• Obtemos o endereco efetivo adicionando o valor no registrador de modificacao a um valor base que pode ser armazenado em outro registrador ou no contador do programa, ou mesmo em um valor imediato;
• Um dos registradores de modificacao mais usados eh o registrador de indice;
• Geralmente chamamos o registrador contendo o valor base de registrador base;
  • Nesse caso, a maioria das CPUs cria o endereco efetivo simplesmente adicionando o valor no registrador base e o valor no registrador de modificacao.
• Ao usar a modificacao de endereco dessa forma eh possivel obter efeitos muito praticos, como, por exemplo, extrair algum dado particular de um conjunto especificando o deslocamento no registrador de indice e o inicio dos dados definido em um registrador base.

Inconditional#

• Usamos a instrucoa JMP, e nao depende que nada ocorra;
• Simplificadamente, apenas pula para pontos “etiquetados” (marcadores / labels) do programa.

Conditional#

• Usamos, para expressar e representar saltos condicionais, as letras jcc;
• http://unixwiz.net/techtips/x86-jumps.html

How Call / Ret Works?#

• O funcionamento das instrucoes CALL e RET esta diretamente ligado a pilha de execucao (stack), que eh usada para armazenar o endereco de retorno quando uma sub-rotina (funcao) eh chamada.

1
> Suponha que o `EIP` esteja em `0x1000` e chamamos `CALL` para `0x2000`.
2

3
| Endereco | Conteudo (antes do CALL) |
4
|----------|--------------------------|
5
| ...      | ...                      |
6
| 0xFFFC   | ???                      |
7

8
> Apos `CALL 0x2000`:
9

10
| Endereco | Conteudo (depois do CALL) |
11
|----------|---------------------------|
12
| ...      | ...                       |
13
| 0xFFFC   | 0x1003 (endereco de ret)  |
14

15
> Agora, quando `RET` for chamado dentro da funcao em `0x2000`:
16
    1. O endereco `0x1003` sera retirado da pilha;
17
    2. A execucao continuara a partir de `0x1003`.

Load Effective Address (lea)#

• Instrucao utilizada para calcular enderecos, ou seja, obter endereco de memoria de uma variavel ou expressa o sem acessar o conteudo da memoria naquele endereco;
• Simplificadamente, calcula um endereco e o coloca em um registrador, nao acessando diretamente a memoria;
• Quando usar:
  • Calcular enderecos (como ao obter o endereco de uma variavel ou de um elemento em um array);
  • Quando se precisa de um valor em um registrador, mas nao quer acessar diretamente o valor armazenado na memoria.