# 5. Bibliotecas e Importacao

## Introdução

O **Assembly** é uma linguagem de programação de baixo nível que traduz instruções de máquina diretamente executáveis pelo processador, específica para arquiteturas como x86, MIPS ou ARM. Esta documentação cobre os fundamentos do Assembly, com ênfase em **bibliotecas** e **importação de arquivos** (locais e remotos), detalhando sua implementação, características, boas práticas e uma comparação com linguagens de alto nível como **Python**, **Bash** e **C**. Em Assembly, "bibliotecas" e "importações" diferem significativamente de linguagens de alto nível, pois dependem de ligação de código (linking) e chamadas ao sistema operacional.

## Estrutura Básica de um Programa Assembly

Um programa Assembly é um arquivo de texto (extensão `.asm` ou `.s`) com instruções traduzidas por um assembler (e.g., NASM para x86, mips-as para MIPS) em código de máquina. Abaixo, um exemplo em x86-64 que usa uma biblioteca externa (libc):

```nasm
; programa.asm - Usando printf da libc
section .text
    global _start
    extern printf       ; Declara função externa da libc

_start:
    mov rdi, fmt        ; Formato da string
    mov rsi, 42         ; Argumento
    xor rax, rax        ; Sem argumentos de ponto flutuante
    call printf         ; Chama função da libc
    mov rax, 60         ; Syscall sair
    xor rdi, rdi
    syscall

section .data
    fmt db "Número: %d", 0xa, 0
```

* `section .text`: Contém o código executável.
* `section .data`: Define dados inicializados.
* `extern`: Declara símbolos externos (bibliotecas).
* `;`: Inicia um comentário.

## Instruções Básicas

### Operações com Registradores

| Instrução | Descrição    | Exemplo (x86) | Exemplo (MIPS) |
| --------- | ------------ | ------------- | -------------- |
| `MOV`     | Copia dados  | `mov rax, 42` | `li $t0, 42`   |
| `CALL`    | Chama função | `call printf` | `jal printf`   |
| `RET`     | Retorna      | `ret`         | `jr $ra`       |

### 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)` |

***

## Bibliotecas em Assembly

### Definição e Implementação

Em Assembly, bibliotecas são coleções de funções ou dados pré-compilados, geralmente fornecidos pelo sistema operacional (e.g., `libc` em sistemas Unix-like) ou criados pelo programador. Elas são vinculadas (linked) ao programa durante a compilação ou em tempo de execução.

### Tipos de Bibliotecas

| Tipo               | Extensão (Linux) | Descrição                                       |
| ------------------ | ---------------- | ----------------------------------------------- |
| **Estáticas**      | `.a`             | Incorporadas ao executável (arquivo estático)   |
| **Dinâmicas**      | `.so`            | Carregadas em tempo de execução (shared object) |
| **Personalizadas** | `.o`             | Módulos Assembly ou C compilados separadamente  |

### Uso de Bibliotecas Padrão (libc)

#### x86-64 com libc

```nasm
; usando_libc.asm
extern printf, scanf, exit

section .data
    prompt db "Digite um número: ", 0
    fmt_in db "%d", 0
    fmt_out db "Você digitou: %d", 0xa, 0

section .bss
    numero resd 1

section .text
    global _start

_start:
    ; Exibe prompt
    mov rdi, prompt
    call printf
    
    ; Lê número
    mov rdi, fmt_in
    mov rsi, numero
    call scanf
    
    ; Exibe resultado
    mov rdi, fmt_out
    mov esi, [numero]
    call printf
    
    ; Sai
    mov rdi, 0
    call exit
```

Compilação e linkagem:

```bash
nasm -f elf64 usando_libc.asm -o usando_libc.o
gcc -no-pie usando_libc.o -o usando_libc
./usando_libc
```

#### MIPS com libc

```nasm
# usando_libc.s
.data
    prompt: .asciiz "Digite um número: "
    fmt_in: .asciiz "%d"
    fmt_out: .asciiz "Você digitou: %d\n"

.bss
    numero: .space 4

.text
    .globl main

main:
    # Exibe prompt
    la $a0, prompt
    li $v0, 4           # syscall print_string
    syscall
    
    # Lê número
    la $a0, fmt_in
    la $a1, numero
    jal scanf
    
    # Exibe resultado
    la $a0, fmt_out
    lw $a1, numero
    jal printf
    
    # Sai
    li $v0, 10
    syscall
```

Compilação:

```bash
mips-linux-gnu-gcc usando_libc.s -o usando_libc
qemu-mips ./usando_libc
```

### Criando Bibliotecas Personalizadas

{% stepper %}
{% step %}

### Criar um Módulo Assembly

**math\_lib.asm** (funções matemáticas):

```nasm
; math_lib.asm - Biblioteca de funções matemáticas
section .text
    global soma
    global subtracao
    global multiplicacao
    global divisao

; int soma(int a, int b)
soma:
    mov eax, edi        ; a
    add eax, esi        ; a + b
    ret

; int subtracao(int a, int b)
subtracao:
    mov eax, edi
    sub eax, esi
    ret

; int multiplicacao(int a, int b)
multiplicacao:
    mov eax, edi
    imul eax, esi
    ret

; int divisao(int a, int b) - divisão inteira
divisao:
    mov eax, edi
    cdq
    idiv esi
    ret
```

{% endstep %}

{% step %}

### Compilar o Módulo

```bash
nasm -f elf64 math_lib.asm -o math_lib.o
```

{% endstep %}

{% step %}

### Criar Biblioteca Estática

```bash
ar rcs libmath.a math_lib.o
```

{% endstep %}

{% step %}

### Usar a Biblioteca

**main.asm**:

```nasm
; main.asm - Usando biblioteca estática
extern soma
extern multiplicacao

section .data
    fmt db "Resultado: %d", 0xa, 0

section .text
    global _start
    extern printf

_start:
    ; Testa soma
    mov rdi, 10
    mov rsi, 20
    call soma           ; resultado em eax
    
    ; Exibe resultado
    mov rdi, fmt
    mov esi, eax
    call printf
    
    ; Testa multiplicação
    mov rdi, 5
    mov rsi, 6
    call multiplicacao  ; resultado em eax
    
    ; Exibe resultado
    mov rdi, fmt
    mov esi, eax
    call printf
    
    ; Finaliza
    mov rax, 60
    xor rdi, rdi
    syscall
```

Compilação e linkagem:

```bash
nasm -f elf64 main.asm -o main.o
gcc -no-pie main.o -L. -lmath -o programa
./programa
```

{% endstep %}
{% endstepper %}

### Bibliotecas Dinâmicas (Shared Objects)

#### Criar Biblioteca Dinâmica

```bash
# Compilar com position-independent code
nasm -f elf64 math_lib.asm -o math_lib.o -DPIC
gcc -shared -o libmath.so math_lib.o

# Ou usando apenas GCC
gcc -shared -o libmath.so math_lib.asm
```

#### Usar Biblioteca Dinâmica

```bash
# Compilar
gcc -no-pie main.o -L. -lmath -o programa

# Executar (definir caminho da biblioteca)
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
./programa

# Verificar dependências
ldd programa
```

***

## Importação de Arquivos Locais

### Inclusão de Código com `%include` (NASM)

**modulo.asm**:

```nasm
; modulo.asm - Código reutilizável
%ifndef MODULO_ASM
%define MODULO_ASM

; Função saudacao
saudacao:
    mov rsi, msg_saudacao
    mov rdx, len_saudacao
    mov rax, 1
    mov rdi, 1
    syscall
    ret

section .data
    msg_saudacao db "Olá do módulo!", 0xa
    len_saudacao equ $ - msg_saudacao

%endif
```

**main.asm**:

```nasm
; main.asm - Usando %include
%include "modulo.asm"

section .text
    global _start

_start:
    call saudacao       ; Função do módulo
    mov rax, 60
    xor rdi, rdi
    syscall
```

### Inclusão com `.include` (MIPS)

**modulo.s**:

```nasm
# modulo.s
.macro saudacao
    la $a0, msg_saudacao
    li $v0, 4
    syscall
.end_macro

.data
    msg_saudacao: .asciiz "Olá do módulo!\n"
```

**main.s**:

```nasm
# main.s
.include "modulo.s"

.text
    .globl main
main:
    saudacao            # Macro do módulo
    li $v0, 10
    syscall
```

### Objetos Separados (Linking)

```bash
# Compilar módulos separadamente
nasm -f elf64 modulo1.asm -o modulo1.o
nasm -f elf64 modulo2.asm -o modulo2.o
nasm -f elf64 main.asm -o main.o

# Linkar todos os objetos
ld main.o modulo1.o modulo2.o -o programa
```

***

## Importação de Arquivos Remotos

Assembly não possui suporte nativo para importar arquivos remotos diretamente. Isso é feito indiretamente via ferramentas externas (e.g., `curl`, `wget`) para baixar código ou bibliotecas, seguido de compilação e ligação.

### Fluxo Típico com curl

```bash
# 1. Baixar arquivo remoto
curl -o modulo.asm https://exemplo.com/biblioteca/modulo.asm

# 2. Verificar integridade (opcional)
sha256sum modulo.asm

# 3. Compilar
nasm -f elf64 modulo.asm -o modulo.o

# 4. Compilar programa principal
nasm -f elf64 main.asm -o main.o

# 5. Linkar
ld main.o modulo.o -o programa

# 6. Executar
./programa
```

### Download de Biblioteca Dinâmica Remota

```bash
# 1. Baixar biblioteca compartilhada
curl -o libcustom.so https://exemplo.com/libs/libcustom.so

# 2. Instalar ou usar com LD_LIBRARY_PATH
sudo cp libcustom.so /usr/local/lib/
sudo ldconfig

# ou usar localmente
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH

# 3. Compilar e linkar
gcc -no-pie main.o -L. -lcustom -o programa
```

### Script Automatizado para Importação

**import.sh**:

```bash
#!/bin/bash
# Script para importar e compilar biblioteca remota

URL="https://exemplo.com/biblioteca/modulo.asm"
FILE="modulo.asm"
CHECKSUM_URL="https://exemplo.com/biblioteca/modulo.sha256"

# Download com verificação
curl -s -o "$FILE" "$URL"
curl -s -o "$FILE.sha256" "$CHECKSUM_URL"

# Verificar checksum
if sha256sum -c "$FILE.sha256" 2>/dev/null; then
    echo "Verificação OK"
else
    echo "ERRO: Checksum inválido!"
    exit 1
fi

# Compilar
nasm -f elf64 "$FILE" -o "${FILE%.asm}.o"

echo "Importação concluída: ${FILE%.asm}.o"
```

### Cuidados com Importação Remota

| Cuidado       | Descrição                            | Solução                                      |
| ------------- | ------------------------------------ | -------------------------------------------- |
| **Segurança** | Scripts remotos podem ser maliciosos | Verificar checksum, inspecionar código       |
| **Conexão**   | Falha de rede pode interromper build | Usar HTTPS, verificar status HTTP            |
| **Versões**   | API pode mudar                       | Especificar versão na URL                    |
| **Cache**     | Downloads repetidos desnecessários   | Armazenar localmente, verificar atualizações |

***

## Comparação com Outras Linguagens

| Aspecto                   | Assembly (x86/MIPS)       | Python           | Bash                 | C                     |
| ------------------------- | ------------------------- | ---------------- | -------------------- | --------------------- |
| **Bibliotecas**           | `extern`, linker manual   | `import modulo`  | `source modulo.sh`   | `#include <lib>`      |
| **Importação Local**      | `%include`, objetos `.o`  | `import modulo`  | `source ./modulo.sh` | `#include "modulo.h"` |
| **Importação Remota**     | Manual via `curl`, linker | `pip install`    | `curl \| bash`       | `make`, repositórios  |
| **Bibliotecas Dinâmicas** | `.so`, `LD_LIBRARY_PATH`  | `.so` via ctypes | Não nativo           | `.so`, `dlopen()`     |
| **Abstração**             | Mínima, manual            | Alta, automática | Moderada             | Moderada              |

### Exemplo em Python

```python
# Importação local
import math
from modulo import funcao

# Importação remota
# pip install requests
import requests
```

### Exemplo em Bash

```bash
# Importação local
source ./modulo.sh

# Importação remota
source <(curl -s https://exemplo.com/script.sh)
```

### Exemplo em C

```c
// Importação local
#include <stdio.h>
#include "modulo.h"

// Importação remota (via build system)
// #include <curl/curl.h>  // Instalado via apt/pacman
```

***

## Boas Práticas

### 1. Bibliotecas

* Use `extern` para símbolos claros
* Prefira bibliotecas padrão (`libc`) para portabilidade
* Documente dependências externas no cabeçalho do arquivo
* Use `-z noexecstack` para segurança

### 2. Importação Local

* Organize módulos em diretórios estruturados
* Use `%include` para pequenos arquivos, linker para grandes
* Crie arquivos de cabeçalho com protótipos
* Use guardas de inclusão (`%ifndef`)

### 3. Importação Remota

* Valide arquivos baixados (checksums, assinaturas)
* Use HTTPS para downloads
* Armazene em cache para builds repetidos
* Nunca execute código remoto sem inspeção

### 4. Estrutura de Projeto

```
meu_projeto/
├── src/
│   ├── main.asm
│   └── utils.asm
├── include/
│   └── utils.inc          # Macros e constantes
├── lib/
│   └── libmath.a          # Biblioteca estática
├── build/
│   └── *.o
├── Makefile
└── README.md
```

### 5. Makefile Exemplo

```makefile
# Makefile para projeto Assembly
AS = nasm
ASFLAGS = -f elf64
LD = ld
LDFLAGS = 
CC = gcc
CCFLAGS = -no-pie

SOURCES = $(wildcard src/*.asm)
OBJECTS = $(patsubst src/%.asm, build/%.o, $(SOURCES))
TARGET = programa

all: $(TARGET)

$(TARGET): $(OBJECTS)
	$(LD) $(OBJECTS) -o $(TARGET)

build/%.o: src/%.asm | build
	$(AS) $(ASFLAGS) $< -o $@

build:
	mkdir -p build

# Com libc
libc: $(OBJECTS)
	$(CC) $(CCFLAGS) $(OBJECTS) -o $(TARGET)

clean:
	rm -rf build $(TARGET)

.PHONY: all clean libc
```

***

## Ferramentas para Análise

| Comando      | Finalidade                   | Exemplo                 |
| ------------ | ---------------------------- | ----------------------- |
| `ldd`        | Listar bibliotecas dinâmicas | `ldd programa`          |
| `nm`         | Listar símbolos de objeto    | `nm libmath.a`          |
| `objdump -T` | Símbolos dinâmicos           | `objdump -T libmath.so` |
| `readelf -d` | Dependências ELF             | `readelf -d programa`   |
| `strace`     | Monitorar syscalls           | `strace ./programa`     |
| `ldconfig`   | Configurar bibliotecas       | `sudo ldconfig`         |

***

## Exemplo Completo: Calculadora com Biblioteca

### biblioteca.asm

```nasm
; biblioteca.asm - Biblioteca de operações matemáticas
section .text
    global soma, subtracao, multiplicacao, divisao, potencia

; int soma(int a, int b)
soma:
    mov eax, edi
    add eax, esi
    ret

; int subtracao(int a, int b)
subtracao:
    mov eax, edi
    sub eax, esi
    ret

; int multiplicacao(int a, int b)
multiplicacao:
    mov eax, edi
    imul eax, esi
    ret

; int divisao(int a, int b)
divisao:
    mov eax, edi
    cdq
    idiv esi
    ret

; int potencia(int base, int exp)
potencia:
    push rbx
    mov eax, 1          ; resultado = 1
    mov ebx, edi        ; base
    mov ecx, esi        ; expoente
.power_loop:
    cmp ecx, 0
    je .power_done
    imul eax, ebx
    dec ecx
    jmp .power_loop
.power_done:
    pop rbx
    ret
```

### calculadora.asm

```nasm
; calculadora.asm - Programa principal
extern printf, scanf, exit
extern soma, subtracao, multiplicacao, divisao, potencia

section .data
    menu db "Calculadora Assembly", 0xa
         db "1 - Soma", 0xa
         db "2 - Subtração", 0xa
         db "3 - Multiplicação", 0xa
         db "4 - Divisão", 0xa
         db "5 - Potência", 0xa
         db "0 - Sair", 0xa
         db "Escolha: ", 0
    
    fmt_int db "%d", 0
    fmt_result db "Resultado: %d", 0xa, 0
    fmt_erro db "Erro: Divisão por zero!", 0xa, 0
    fmt_invalido db "Opção inválida!", 0xa, 0

section .bss
    opcao resd 1
    num1 resd 1
    num2 resd 1
    resultado resd 1

section .text
    global _start

_start:
    ; Exibe menu
    mov rdi, menu
    call printf
    
    ; Lê opção
    mov rdi, fmt_int
    mov rsi, opcao
    call scanf
    
    ; Verifica sair
    mov eax, [opcao]
    cmp eax, 0
    je .sair
    
    ; Lê primeiro número
    mov rdi, fmt_int
    mov rsi, num1
    call scanf
    
    ; Lê segundo número
    mov rdi, fmt_int
    mov rsi, num2
    call scanf
    
    ; Executa operação baseada na opção
    mov eax, [opcao]
    cmp eax, 1
    je .soma
    cmp eax, 2
    je .subtracao
    cmp eax, 3
    je .multiplicacao
    cmp eax, 4
    je .divisao
    cmp eax, 5
    je .potencia
    jmp .invalido

.soma:
    mov edi, [num1]
    mov esi, [num2]
    call soma
    jmp .exibir

.subtracao:
    mov edi, [num1]
    mov esi, [num2]
    call subtracao
    jmp .exibir

.multiplicacao:
    mov edi, [num1]
    mov esi, [num2]
    call multiplicacao
    jmp .exibir

.divisao:
    mov eax, [num2]
    cmp eax, 0
    je .erro_divisao
    mov edi, [num1]
    mov esi, [num2]
    call divisao
    jmp .exibir

.potencia:
    mov edi, [num1]
    mov esi, [num2]
    call potencia
    jmp .exibir

.erro_divisao:
    mov rdi, fmt_erro
    call printf
    jmp .fim

.invalido:
    mov rdi, fmt_invalido
    call printf
    jmp .fim

.exibir:
    mov [resultado], eax
    mov rdi, fmt_result
    mov esi, [resultado]
    call printf

.fim:
    jmp _start

.sair:
    mov rdi, 0
    call exit
```

### Compilação e Execução

```bash
# Compilar biblioteca
nasm -f elf64 biblioteca.asm -o biblioteca.o

# Compilar programa principal
nasm -f elf64 calculadora.asm -o calculadora.o

# Linkar com libc e biblioteca
gcc -no-pie calculadora.o biblioteca.o -o calculadora

# Executar
./calculadora
```

***

## Recursos Adicionais

* **Livro Gratuito**: [Aprendendo Assembly](https://mentebinaria.gitbook.io/assembly) (x86/x86-64)
* **Manuais Intel**: [Volume 2A](https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html)
* **Ferramentas**: NASM ([nasm.us](https://nasm.us/)), PEDA ([github.com/longld/peda](https://github.com/longld/peda))
* **GCC Documentation**: [Linker Options](https://gcc.gnu.org/onlinedocs/gcc/Link-Options.html)


---

# 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/5.-bibliotecas-e-importacao.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.