# Assembly

## Introdução

O **Assembly** é uma linguagem de programação de baixo nível que representa, de forma textual, as instruções de máquina executadas diretamente pelo processador. Cada instrução em Assembly corresponde a uma operação específica do hardware, como manipulação de registradores ou acesso à memória, sendo dependente da arquitetura do processador (e.g., x86, MIPS, ARM).

```mermaid
flowchart TD
    A[Escrever código Assembly na IDE] --> B[Salvar com extensão .asm]
    B --> C[Assembler: NASM, MASM, mips-as]
    C --> D[Traduz para código de máquina - arquivo .obj/.o]
    D --> E[Linker: ld, gcc, Visual Studio Linker]
    E --> F[Combina com bibliotecas - gera executável]
    F --> G[Sistema Operacional carrega o executável na memória]
    G --> H[CPU busca instruções na memória - Fetch]
    H --> I[Unidade de Controle decodifica instruções - Decode]
    I --> J[Unidade Lógica e Aritmética executa operações - Execute]
    J --> K[Resultados armazenados em registradores/memória]

    subgraph "Processador"
        H --> I --> J
    end
```

## Como o Computador "Entende" Assembly

{% stepper %}
{% step %}

#### IDE/Editor

O programador escreve o código Assembly (ex: `mov rax, 5`).
{% endstep %}

{% step %}

#### Assembler

Converte o código para **código de máquina** (binário) e resolve endereços simbólicos.
{% endstep %}

{% step %}

#### Linker

Adiciona bibliotecas e cria o formato executável (ELF no Linux, PE no Windows).
{% endstep %}

{% step %}

#### Sistema Operacional

Carrega o executável na memória RAM e prepara o contexto de execução.
{% endstep %}

{% step %}

#### CPU

* **Fetch**: Busca a instrução da memória.
* **Decode**: Decifra o opcode (ex: `B8 05 00 00 00` significa `mov eax, 5`).
* **Execute**: A ULA realiza a operação e atualiza os registradores.
  {% endstep %}
  {% endstepper %}

Cada instrução em Assembly mapeia diretamente para um **opcode** binário definido pelo conjunto de instruções (ISA) da CPU.

***

## Estrutura Básica de um Programa Assembly

Um programa em Assembly é um arquivo de texto (geralmente com extensão `.asm` ou `.s`) contendo instruções que são traduzidas por um assembler em código de máquina. Abaixo está um exemplo simples em x86-64:

```nasm
; programa.asm
section .text
    global _start          ; Ponto de entrada

_start:
    mov rax, 1             ; syscall write
    mov rdi, 1             ; stdout
    mov rsi, msg           ; endereço da mensagem
    mov rdx, len           ; comprimento
    syscall                ; chama o sistema

    mov rax, 60            ; syscall exit
    xor rdi, rdi           ; código de saída 0
    syscall

section .data
    msg db 'Olá, mundo!', 0xa  ; mensagem com newline
    len equ $ - msg            ; comprimento calculado
```

### Elementos do Programa

| Elemento        | Descrição                              |
| --------------- | -------------------------------------- |
| `section .text` | Seção de código executável             |
| `section .data` | Seção de dados inicializados           |
| `section .bss`  | Seção de dados não inicializados       |
| `global _start` | Declara o ponto de entrada do programa |
| `;`             | Inicia um comentário                   |
| `syscall`       | Invoca o sistema operacional           |

***

## Instruções Básicas

### Operações com Registradores

| Instrução | Descrição   | Exemplo (x86-64) |
| --------- | ----------- | ---------------- |
| `mov`     | Copia dados | `mov rax, 42`    |
| `add`     | Soma        | `add rax, rbx`   |
| `sub`     | Subtrai     | `sub rax, 5`     |
| `inc`     | Incrementa  | `inc rax`        |
| `dec`     | Decrementa  | `dec rcx`        |
| `mul`     | Multiplica  | `mul rbx`        |
| `div`     | Divide      | `div rcx`        |

### Manipulação de Memória

| Arquitetura | Leitura          | Escrita          |
| ----------- | ---------------- | ---------------- |
| x86-64      | `mov eax, [rbx]` | `mov [rbx], eax` |
| MIPS        | `lw $t0, 0($t1)` | `sw $t0, 0($t1)` |

### Controle de Fluxo

| Instrução     | Descrição                        | Exemplo       |
| ------------- | -------------------------------- | ------------- |
| `jmp`         | Salto incondicional              | `jmp loop`    |
| `je` / `jz`   | Salta se igual/zero              | `je igual`    |
| `jne` / `jnz` | Salta se diferente/não zero      | `jne fim`     |
| `jg` / `jl`   | Salta se maior/menor (com sinal) | `jg maior`    |
| `ja` / `jb`   | Salta se maior/menor (sem sinal) | `ja acima`    |
| `call`        | Chama função                     | `call funcao` |
| `ret`         | Retorna de função                | `ret`         |

### Operações Lógicas

| Instrução | Descrição     | Exemplo                           |
| --------- | ------------- | --------------------------------- |
| `and`     | AND bit a bit | `and rax, rbx`                    |
| `or`      | OR bit a bit  | `or rax, 0xFF`                    |
| `xor`     | XOR bit a bit | `xor rax, rax` (zera registrador) |
| `not`     | NOT bit a bit | `not rax`                         |
| `shl`     | Shift left    | `shl rax, 2`                      |
| `shr`     | Shift right   | `shr rax, 1`                      |

***

## Variáveis em Assembly

Em Assembly, não há variáveis como em linguagens de alto nível. Dados são armazenados em registradores ou memória, identificados por **rótulos**:

```nasm
section .data
    numero dd 42          ; Define inteiro de 32 bits
    mensagem db 'Texto', 0 ; String terminada por null

section .bss
    buffer resb 256       ; Reserva 256 bytes não inicializados

section .text
    mov eax, [numero]     ; Carrega valor da memória
    mov [buffer], al      ; Armazena byte na memória
```

***

## Estruturas de Controle

### Condicional (If-Else)

```nasm
    cmp rax, rbx          ; Compara rax com rbx
    je igual              ; Salta se igual
    mov rcx, 0            ; Else
    jmp fim
igual:
    mov rcx, 1            ; Then
fim:
```

### Laço (Loop)

```nasm
    mov rcx, 10           ; Contador
loop_start:
    ; ... código ...
    dec rcx               ; Decrementa contador
    jnz loop_start        ; Continua se não zero
```

***

## Permissões e Execução

{% tabs %}
{% tab title="x86-64 (Linux)" %}

```bash
# Compilar com NASM
nasm -f elf64 programa.asm -o programa.o

# Linkar com ld
ld programa.o -o programa

# Executar
./programa

# Ou linkar com libc
gcc -no-pie programa.o -o programa
```

{% endtab %}

{% tab title="MIPS (Linux)" %}

```bash
# Compilar com mips-as
mips-linux-gnu-as programa.s -o programa.o

# Linkar
mips-linux-gnu-ld programa.o -o programa

# Executar (emulador)
qemu-mips ./programa
```

{% endtab %}
{% endtabs %}

***

## Comparação com Linguagens de Alto Nível

| Aspecto                      | Assembly                   | Python              | Bash               |
| ---------------------------- | -------------------------- | ------------------- | ------------------ |
| **Nível de abstração**       | Baixo (hardware)           | Alto                | Médio              |
| **Tipagem**                  | Não tipado                 | Dinâmica            | Dinâmica (strings) |
| **Gerenciamento de memória** | Manual                     | Automático          | Automático         |
| **Portabilidade**            | Específico por arquitetura | Portável            | Portável           |
| **Eficiência**               | Máxima                     | Moderada            | Baixa              |
| **Curva de aprendizado**     | Íngreme                    | Suave               | Moderada           |
| **Uso típico**               | Drivers, embarcados, RE    | Scripts, web, dados | Automação, scripts |

***

## Importância do Assembly

### Na História

* Assembly foi essencial nos anos 1940-50, substituindo código binário por mnemônicos
* Facilitou o desenvolvimento dos primeiros sistemas operacionais (UNIX, DOS)
* Crucial para a criação dos primeiros compiladores de linguagens de alto nível

### No Dia a Dia

* **Sistemas Embarcados**: Microcontroladores em carros, eletrodomésticos, IoT
* **Otimização**: Trechos críticos de jogos, engines, bibliotecas
* **Engenharia Reversa**: Análise de malware, exploits, segurança
* **Sistemas Operacionais**: Bootloaders, kernels, drivers
* **Educação**: Entendimento profundo do funcionamento do hardware

***

## Boas Práticas

1. **Documentação**:
   * Comente cada seção e instrução complexa
   * Use rótulos descritivos (`loop_inicio`, `erro_arquivo`)
2. **Organização**:
   * Separe código, dados e variáveis em seções
   * Agrupe funções relacionadas
   * Use macros para código repetitivo
3. **Segurança**:
   * Valide limites de buffers
   * Evite execução de código em seções de dados
   * Use `-z noexecstack` no linker
4. **Depuração**:
   * Use GDB com `layout asm`
   * Verifique registradores com `info registers`
   * Utilize breakpoints estratégicos

***

## Ferramentas Recomendadas

| Ferramenta   | Uso                                      |
| ------------ | ---------------------------------------- |
| **NASM**     | Assembler para x86/x86-64                |
| **GAS (as)** | Assembler GNU (ARM, MIPS, x86)           |
| **GDB**      | Depurador com suporte a Assembly         |
| **ld**       | Linker básico                            |
| **objdump**  | Visualizar seções: `objdump -d programa` |
| **readelf**  | Analisar cabeçalhos ELF                  |
| **strace**   | Monitorar syscalls                       |
| **QEMU**     | Emulação de outras arquiteturas          |

***

## Recursos Adicionais

### Livros e Manuais

* **Aprendendo Assembly** (Mente Binária) - [Link](https://mentebinaria.gitbook.io/assembly)
* **Intel 64 and IA-32 Architectures Software Developer Manuals** - [Volume 2A](https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html)
* **MIPS Architecture Manual** - Capítulo 11 (fornecido em PDF)
* **Programming from the Ground Up** - Jonathan Bartlett

### Ferramentas Online

* **Compiler Explorer** - [godbolt.org](https://godbolt.org/) (visualiza Assembly de código C)
* **Online Assembler** - [onlineasm.net](https://onlineasm.net/)
* **x86-64 Reference** - [felixcloutier.com/x86](https://www.felixcloutier.com/x86/)

### Comunidades

* **r/asm** - Subreddit de Assembly
* **Stack Overflow** - Tag \[assembly]
* **Mente Binária** - Comunidade brasileira


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/conceitos/programacao-e-linguagens/assembly.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.