# Binário

> **Um guia abrangente sobre o sistema binário** – desde os fundamentos da numeração posicional até aplicações práticas em computação, programação, análise forense e engenharia reversa.

***

## 🔍 Introdução ao Sistema Binário

### 1.1 O que é Binário?

O **sistema binário** (base 2) é um sistema de numeração posicional que utiliza apenas **dois símbolos** para representar valores: **0 e 1**. Cada dígito binário é chamado de **bit** (contração de *binary digit*).

| **Decimal** | **Binário** |
| ----------- | ----------- |
| 0           | 0           |
| 1           | 1           |
| 2           | 10          |
| 3           | 11          |
| 4           | 100         |
| 5           | 101         |
| 6           | 110         |
| 7           | 111         |
| 8           | 1000        |
| 9           | 1001        |
| 10          | 1010        |

### 1.2 Histórico e Origem

O conceito do sistema binário remonta à antiguidade, mas sua formalização moderna é atribuída a **Gottfried Wilhelm Leibniz**, que em 1703 publicou o artigo *"Explication de l'arithmétique binaire"* onde descreveu o sistema de numeração usando 0 e 1, relacionando-o ao I Ching (antigo texto chinês) .

**Marcos históricos:**

| **Ano**     | **Evento**                                                             |
| ----------- | ---------------------------------------------------------------------- |
| \~3000 a.C. | Egípcios e chineses usam sistemas baseados em 2 para medição           |
| 1703        | Leibniz publica trabalho sobre aritmética binária                      |
| 1847        | George Boole desenvolve álgebra booleana                               |
| 1937        | Claude Shannon aplica álgebra booleana a circuitos elétricos           |
| 1945        | ENIAC, primeiro computador eletrônico de uso geral (decimal)           |
| 1948        | Manchester Baby, primeiro computador com programa armazenado (binário) |

### 1.3 Por que os Computadores Usam Binário?

Os computadores utilizam o sistema binário por razões **físicas e eletrônicas** fundamentais:

| **Razão**                    | **Descrição**                                                                                           |
| ---------------------------- | ------------------------------------------------------------------------------------------------------- |
| **Simplicidade do Hardware** | Representar dois estados (0 e 1) é mais fácil: ligado/desligado, alta/baixa tensão, norte/sul magnético |
| **Tolerância a Ruído**       | Diferenciação clara entre dois estados é mais confiável que múltiplos níveis                            |
| **Confiabilidade**           | Menor probabilidade de erro na transmissão e armazenamento                                              |
| **Lógica Booleana**          | Álgebra booleana (AND, OR, NOT) se mapeia diretamente em circuitos digitais                             |
| **Teorema de Shannon**       | Provou que qualquer operação lógica pode ser implementada com portas binárias                           |

***

## 📐 Fundamentos Matemáticos

### 2.1 Sistemas de Numeração: Decimal, Binário e Hexadecimal

#### Sistema Decimal (Base 10)

* **Símbolos**: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
* **Posições**: ... 10³, 10², 10¹, 10⁰
* **Exemplo**: 123₁₀ = (1 × 10²) + (2 × 10¹) + (3 × 10⁰) = 100 + 20 + 3

#### Sistema Binário (Base 2)

* **Símbolos**: 0, 1
* **Posições**: ... 2³, 2², 2¹, 2⁰
* **Exemplo**: 1011₂ = (1 × 2³) + (0 × 2²) + (1 × 2¹) + (1 × 2⁰) = 8 + 0 + 2 + 1 = 11₁₀

#### Relação entre Bases

Cada dígito hexadecimal representa exatamente 4 bits (nibble), facilitando conversões:

| **Binário** | **Hexadecimal** | **Decimal** |
| ----------- | --------------- | ----------- |
| 0000        | 0               | 0           |
| 0001        | 1               | 1           |
| ...         | ...             | ...         |
| 1010        | A               | 10          |
| 1111        | F               | 15          |

### 2.2 Conversões entre Sistemas

#### Decimal para Binário

**Método: Divisões sucessivas por 2**

**Exemplo:** Converter 45₁₀ para binário

| Passo | Divisão | Quociente | Resto |
| ----- | ------- | --------- | ----- |
| 1     | 45 ÷ 2  | 22        | 1     |
| 2     | 22 ÷ 2  | 11        | 0     |
| 3     | 11 ÷ 2  | 5         | 1     |
| 4     | 5 ÷ 2   | 2         | 1     |
| 5     | 2 ÷ 2   | 1         | 0     |
| 6     | 1 ÷ 2   | 0         | 1     |

Lendo os restos de baixo para cima: **101101₂**

**Verificação:** 32 + 8 + 4 + 1 = 45 ✅

#### Binário para Decimal

**Método: Multiplicação por potências de 2**

**Exemplo:** Converter 101101₂ para decimal

```
Posições: 5    4    3    2    1    0
Bits:     1    0    1    1    0    1
Valores: 32   16    8    4    2    1

Cálculo: (1×32) + (0×16) + (1×8) + (1×4) + (0×2) + (1×1) = 32 + 0 + 8 + 4 + 0 + 1 = 45₁₀
```

#### Binário para Hexadecimal

**Método:** Agrupar bits em grupos de 4, da direita para a esquerda

**Exemplo:** Converter 10110110₂ para hexadecimal

```
1011 0110  (agrupar em nibbles)
  B    6   (converter cada nibble)
Resultado: B6₁₆
```

### 2.3 Operações Aritméticas em Binário

#### Adição Binária

| Regra                       | Exemplo |
| --------------------------- | ------- |
| 0 + 0 = 0                   |         |
| 0 + 1 = 1                   |         |
| 1 + 0 = 1                   |         |
| 1 + 1 = 0 (carry 1)         |         |
| 1 + 1 + carry = 1 (carry 1) |         |

**Exemplo:** 1011₂ + 0110₂

```
   1 0 1 1  (11₁₀)
+  0 1 1 0  (6₁₀)
-----------
  1 0 0 0 1  (17₁₀)

Passo a passo (da direita para esquerda):
1 + 0 = 1
1 + 1 = 0 (carry 1)
0 + 1 + carry 1 = 0 (carry 1)
1 + 0 + carry 1 = 0 (carry 1)
carry final = 1
```

#### Subtração Binária

Utiliza o método de "empréstimo" similar ao decimal.

**Exemplo:** 1011₂ - 0110₂

```
   1 0 1 1  (11₁₀)
-  0 1 1 0  (6₁₀)
-----------
   0 1 0 1  (5₁₀)

Passo a passo:
1 - 0 = 1
1 - 1 = 0
0 - 1 = não pode → empresta 1 → 2 - 1 = 1
1 (após empréstimo) - 0 = 1
```

#### Multiplicação Binária

Análoga à multiplicação decimal, mas mais simples.

**Exemplo:** 101₂ × 011₂ (5₁₀ × 3₁₀ = 15₁₀)

```
    1 0 1
×   0 1 1
-----------
    1 0 1   (101 × 1)
  1 0 1     (101 × 1, deslocado)
  0 0 0     (101 × 0, deslocado)
-----------
  1 1 1 1   (15₁₀)
```

### 2.4 Complemento de Dois (Números Negativos)

O **complemento de dois** é o método padrão para representar números inteiros negativos em computadores.

**Algoritmo:**

1. Escrever o valor absoluto em binário
2. Inverter todos os bits (complemento de um)
3. Adicionar 1

**Exemplo:** Representar -5 em 8 bits

```
1. 5 em binário: 00000101
2. Complemento de um: 11111010
3. Adicionar 1: 11111011

Resultado: -5₁₀ = 11111011₂ (8 bits)
```

**Faixa de valores (n bits):**

* **Positivos**: 0 a 2ⁿ⁻¹ - 1
* **Negativos**: -1 a -2ⁿ⁻¹

| **n bits** | **Faixa**                      |
| ---------- | ------------------------------ |
| 8 bits     | -128 a 127                     |
| 16 bits    | -32.768 a 32.767               |
| 32 bits    | -2.147.483.648 a 2.147.483.647 |
| 64 bits    | -9.22×10¹⁸ a 9.22×10¹⁸         |

***

## 📊 Estruturas de Dados Binárias

### 3.1 Bits, Nibbles, Bytes e Palavras

| **Unidade** | **Bits** | **Exemplo (hex)**         |
| ----------- | -------- | ------------------------- |
| **Bit**     | 1        | 0 ou 1                    |
| **Nibble**  | 4        | 1 dígito hex (0-F)        |
| **Byte**    | 8        | 2 dígitos hex (00-FF)     |
| **Word**    | 16       | 4 dígitos hex (0000-FFFF) |
| **DWORD**   | 32       | 8 dígitos hex             |
| **QWORD**   | 64       | 16 dígitos hex            |

### 3.2 Operações Bit a Bit (Bitwise)

| **Operador** | **Símbolo (C/Python)** | **Descrição**                  | **Exemplo**                                |
| ------------ | ---------------------- | ------------------------------ | ------------------------------------------ |
| **AND**      | `&`                    | 1 apenas se ambos bits forem 1 | `1010 & 1100 = 1000`                       |
| **OR**       | \`                     | \`                             | 1 se pelo menos um bit for 1               |
| **XOR**      | `^`                    | 1 se os bits forem diferentes  | `1010 ^ 1100 = 0110`                       |
| **NOT**      | `~`                    | Inverte todos os bits          | `~1010 = 0101` (considerando tamanho fixo) |

**Tabela Verdade:**

| A | B | AND | OR | XOR |
| - | - | --- | -- | --- |
| 0 | 0 | 0   | 0  | 0   |
| 0 | 1 | 0   | 1  | 1   |
| 1 | 0 | 0   | 1  | 1   |
| 1 | 1 | 1   | 1  | 0   |

### 3.3 Deslocamento de Bits (Shift)

| **Operador**    | **Símbolo** | **Descrição**                                  | **Exemplo**         |
| --------------- | ----------- | ---------------------------------------------- | ------------------- |
| **Shift Left**  | `<<`        | Desloca bits para esquerda (multiplica por 2ⁿ) | `1010 << 1 = 10100` |
| **Shift Right** | `>>`        | Desloca bits para direita (divide por 2ⁿ)      | `1010 >> 1 = 0101`  |

**Aplicações:**

* Multiplicação/divisão rápida por potências de 2
* Manipulação de flags e campos de bits
* Geração de números pseudoaleatórios

### 3.4 Máscaras de Bits (Bit Masks)

Máscaras são usadas para isolar ou modificar bits específicos.

```c
// Exemplo em C
uint8_t flags = 0b10110010;

// Extrair apenas os 4 bits superiores
uint8_t high = (flags >> 4) & 0b1111;  // 0b1011

// Extrair apenas os 4 bits inferiores
uint8_t low = flags & 0b1111;          // 0b0010

// Definir o bit 3 (posição 2) como 1
flags |= (1 << 2);                      // 0b10110110

// Limpar o bit 3 (posição 2)
flags &= ~(1 << 2);                     // 0b10110010

// Alternar (toggle) o bit 3
flags ^= (1 << 2);                      // 0b10110110
```

***

## 💻 Representação em Computação

### 4.1 Números Inteiros: Sinal e Magnitude, Complemento de Dois

| **Método**              | **Descrição**                       | **Exemplo (4 bits)** | **Problemas**               |
| ----------------------- | ----------------------------------- | -------------------- | --------------------------- |
| **Sinal e Magnitude**   | Primeiro bit = sinal (0 = +, 1 = -) | +3 = 0011, -3 = 1011 | Dois zeros (+0 e -0)        |
| **Complemento de Um**   | Inverte todos os bits para negativo | +3 = 0011, -3 = 1100 | Dois zeros, adição complexa |
| **Complemento de Dois** | Complemento de um + 1               | +3 = 0011, -3 = 1101 | Único zero, adição simples  |

**Complemento de dois é o padrão em todos os computadores modernos.**

### 4.2 Números de Ponto Flutuante (IEEE 754)

O padrão IEEE 754 define a representação de números reais em binário.

| **Precisão**        | **Bits Total** | **Sinal** | **Expoente** | **Mantissa** | **Faixa Aproximada**     |
| ------------------- | -------------- | --------- | ------------ | ------------ | ------------------------ |
| **Simples (float)** | 32             | 1         | 8            | 23           | ±1.2×10⁻³⁸ a ±3.4×10³⁸   |
| **Dupla (double)**  | 64             | 1         | 11           | 52           | ±2.2×10⁻³⁰⁸ a ±1.8×10³⁰⁸ |

**Estrutura do float (32 bits):**

```
[31] [30-----23] [22-------------------0]
 S    Expoente           Mantissa
 1     8 bits             23 bits
```

**Exemplo:** 5.25₁₀ em float

```
5.25 = 101.01₂ = 1.0101 × 2²
Sinal = 0
Expoente = 2 + 127 = 129 = 10000001₂
Mantissa = 01010000000000000000000₂

Resultado: 0 10000001 01010000000000000000000
```

### 4.3 Caracteres e Strings (ASCII, UTF-8)

**ASCII (American Standard Code for Information Interchange)** - 7 bits (0-127)

| **Caractere** | **Decimal** | **Binário** | **Hex** |
| ------------- | ----------- | ----------- | ------- |
| 'A'           | 65          | 01000001    | 41      |
| 'a'           | 97          | 01100001    | 61      |
| '0'           | 48          | 00110000    | 30      |
| ' ' (espaço)  | 32          | 00100000    | 20      |
| '\n' (LF)     | 10          | 00001010    | 0A      |

**UTF-8** - Codificação variável de 1 a 4 bytes, compatível com ASCII.

### 4.4 Endianness: Little-Endian vs Big-Endian

| **Endianness**    | **Descrição**                     | **Exemplo (0x12345678)** |
| ----------------- | --------------------------------- | ------------------------ |
| **Big-Endian**    | Byte mais significativo primeiro  | `12 34 56 78`            |
| **Little-Endian** | Byte menos significativo primeiro | `78 56 34 12`            |

**Aplicações:**

* **x86/x64 (Intel/AMD)** : Little-Endian
* **ARM** : Configurável (geralmente Little-Endian)
* **Network protocols (TCP/IP)** : Big-Endian
* **PowerPC, SPARC** : Big-Endian

***

## 🎯 Aplicações Práticas do Binário

### 5.1 Permissões de Arquivo (Unix/Linux)

Permissões Unix são representadas por 3 grupos de 3 bits:

| **Bit** | **Valor** | **Permissão** |
| ------- | --------- | ------------- |
| 4       | 100       | Leitura (r)   |
| 2       | 010       | Escrita (w)   |
| 1       | 001       | Execução (x)  |

**Exemplo:** `chmod 755 arquivo`

```
7 = 111 = rwx (proprietário)
5 = 101 = r-x (grupo)
5 = 101 = r-x (outros)
```

| **Octal** | **Binário** | **Permissões** |
| --------- | ----------- | -------------- |
| 0         | 000         | ---            |
| 1         | 001         | --x            |
| 2         | 010         | -w-            |
| 3         | 011         | -wx            |
| 4         | 100         | r--            |
| 5         | 101         | r-x            |
| 6         | 110         | rw-            |
| 7         | 111         | rwx            |

### 5.2 Endereçamento IP e Sub-redes

Endereços IPv4 são 32 bits, geralmente representados em decimal pontuado.

**Exemplo:** `192.168.1.100`

```
192 = 11000000
168 = 10101000
1   = 00000001
100 = 01100100
```

**Cálculo de sub-rede:**

| **Máscara**     | **Binário**                         | **CIDR** | **Hosts**  |
| --------------- | ----------------------------------- | -------- | ---------- |
| 255.0.0.0       | 11111111.00000000.00000000.00000000 | /8       | 16.777.214 |
| 255.255.0.0     | 11111111.11111111.00000000.00000000 | /16      | 65.534     |
| 255.255.255.0   | 11111111.11111111.11111111.00000000 | /24      | 254        |
| 255.255.255.240 | 11111111.11111111.11111111.11110000 | /28      | 14         |

### 5.3 Criptografia e Hashes

Funções hash transformam dados em valores binários de tamanho fixo.

| **Hash** | **Tamanho (bits)** | **Tamanho (bytes)** |
| -------- | ------------------ | ------------------- |
| MD5      | 128                | 16                  |
| SHA-1    | 160                | 20                  |
| SHA-256  | 256                | 32                  |
| SHA-512  | 512                | 64                  |

**Exemplo:** MD5 de "hello" em binário (representação hex):

```
5d41402abc4b2a76b9719d911017c592
```

### 5.4 Compressão de Dados

Algoritmos de compressão exploram redundâncias binárias:

| **Técnica**                   | **Descrição**                                       |
| ----------------------------- | --------------------------------------------------- |
| **RLE (Run-Length Encoding)** | Substitui sequências repetidas por contador + valor |
| **Huffman Coding**            | Codifica símbolos frequentes com menos bits         |
| **LZ77/LZ78**                 | Substitui sequências repetidas por referências      |

### 5.5 Códigos de Correção de Erro (ECC)

| **Código**       | **Descrição**                             |
| ---------------- | ----------------------------------------- |
| **Hamming Code** | Detecta e corrige erros de 1 bit          |
| **Reed-Solomon** | Usado em CDs, QR Codes, códigos de barras |
| **LDPC**         | Usado em Wi-Fi, 5G, armazenamento         |

***

## 🔬 Análise de Dados Binários

### 6.1 Estruturas de Arquivos Binários

Arquivos binários possuem estruturas definidas por cabeçalhos e campos específicos.

**Exemplo de cabeçalho BMP:**

```
Offset (hex) | Tamanho | Campo          | Valor (hex) | Descrição
-------------|---------|----------------|-------------|-------------------
0x00         | 2 bytes | Signature      | 42 4D       | "BM"
0x02         | 4 bytes | FileSize       | 36 00 00 00 | 54 bytes
0x0A         | 4 bytes | DataOffset     | 36 00 00 00 | 54 bytes
```

### 6.2 Executáveis PE, ELF e Mach-O

| **Formato**                              | **Sistema** | **Magic Number**                                            |
| ---------------------------------------- | ----------- | ----------------------------------------------------------- |
| **PE (Portable Executable)**             | Windows     | `4D 5A` (MZ)                                                |
| **ELF (Executable and Linkable Format)** | Linux/Unix  | `7F 45 4C 46` (ELF)                                        |
| **Mach-O**                               | macOS/iOS   | `CF FA ED FE` (little-endian) ou `FE ED FA CF` (big-endian) |

**Estrutura do ELF:**

```
[ELF Header] → [Program Headers] → [Sections] → [Section Headers]
```

### 6.3 Análise Forense de Dados Binários

**Recuperação de arquivos deletados:**

* Carving baseado em assinaturas de arquivo (magic numbers)
* Análise de slack space e unallocated space

```bash
# Recuperar arquivos JPEG deletados
foremost -t jpg -i /dev/sda1 -o /output
```

**Identificação de backdoors:**

* Busca por padrões binários suspeitos
* Análise de ofuscação (xor, base64, etc.)

```bash
# Buscar por opcode de breakpoint (0xCC) em um binário
xxd malware.exe | grep " cc "
```

***

## 🛠️ Ferramentas para Trabalhar com Binário

### 7.1 Editores Binários (Hex Editors)

| **Ferramenta** | **Plataforma**  | **Descrição**                                   |
| -------------- | --------------- | ----------------------------------------------- |
| **HxD**        | Windows         | Editor hex gratuito com análise de RAM e discos |
| **010 Editor** | Win/Mac/Linux   | Editor profissional com templates de estruturas |
| **Hex Fiend**  | Mac             | Editor hex rápido e gratuito                    |
| **ImHex**      | Multiplataforma | Editor hex moderno com analisador de padrões    |

### 7.2 Ferramentas de Análise de Binários

| **Ferramenta**            | **Descrição**                                       |
| ------------------------- | --------------------------------------------------- |
| **radare2**               | Framework de engenharia reversa com análise binária |
| **Ghidra**                | Suite de engenharia reversa da NSA                  |
| **Binary Ninja**          | Analisador binário com interface gráfica            |
| **capa**                  | Identifica capacidades de malware em binários       |
| **PEiD / Detect It Easy** | Identifica packers e compiladores em executáveis    |

### 7.3 Comandos de Linha de Comando

```bash
# Visualizar arquivo em hex
xxd arquivo.bin
xxd -l 100 arquivo.bin     # primeiros 100 bytes
xxd -r arquivo.hex output.bin  # converter hex para binário

# hexdump alternativo
hexdump -C arquivo.bin

# Strings em binário
strings arquivo.exe | head -20

# Informações sobre arquivo
file arquivo.bin
```

```powershell
# Windows PowerShell
Format-Hex arquivo.exe
[Convert]::ToString(255, 2)  # decimal para binário
[Convert]::ToInt32('10101010', 2)  # binário para decimal
```

***

## 🔬 Exemplos Práticos

### 8.1 Analisando Permissões de Arquivo

**Cenário:** `ls -l` mostra `-rwxr-x---`

```
-rwxr-x---
```

**Análise:**

```
rwx = 111 = 7 (proprietário)
r-x = 101 = 5 (grupo)
--- = 000 = 0 (outros)

Permissão octal: 750
```

### 8.2 Calculando Sub-redes IPv4

**Cenário:** IP `192.168.1.100/24`

```
Máscara: /24 = 255.255.255.0
Binário: 11111111.11111111.11111111.00000000
Rede: 192.168.1.0
Broadcast: 192.168.1.255
Hosts: 254 (2⁸ - 2)
```

**Cenário:** IP `10.0.0.5/28`

```
Máscara: /28 = 255.255.255.240
Binário: 11111111.11111111.11111111.11110000
Rede: 10.0.0.0
Broadcast: 10.0.0.15
Hosts: 14 (2⁴ - 2)
```

### 8.3 Decodificando um Número de Ponto Flutuante

**Cenário:** Analisar o valor `0x40490FDB` como float

```
0x40490FDB = 01000000010010010000111111011011

Sinal (bit 31): 0 → positivo
Expoente (bits 30-23): 10000000 = 128
Mantissa (bits 22-0): 10010010000111111011011

Valor = 1.570796... ≈ π/2
```

***

## 📊 Tabelas de Referência Rápida

### 9.1 Potencias de 2

| **n** | **2ⁿ** | **n** | **2ⁿ**            |
| ----- | ------ | ----- | ----------------- |
| 0     | 1      | 10    | 1.024             |
| 1     | 2      | 16    | 65.536            |
| 2     | 4      | 20    | 1.048.576         |
| 3     | 8      | 24    | 16.777.216        |
| 4     | 16     | 30    | 1.073.741.824     |
| 5     | 32     | 32    | 4.294.967.296     |
| 6     | 64     | 40    | 1.099.511.627.776 |
| 7     | 128    | 64    | 1.84×10¹⁹         |
| 8     | 256    | 128   | 3.40×10³⁸         |
| 9     | 512    | 256   | 1.16×10⁷⁷         |

### 9.2 Tabela de Conversão Decimal-Binário-Hexadecimal

| **Decimal** | **Binário (4 bits)** | **Hexadecimal** |
| ----------- | -------------------- | --------------- |
| 0           | 0000                 | 0               |
| 1           | 0001                 | 1               |
| 2           | 0010                 | 2               |
| 3           | 0011                 | 3               |
| 4           | 0100                 | 4               |
| 5           | 0101                 | 5               |
| 6           | 0110                 | 6               |
| 7           | 0111                 | 7               |
| 8           | 1000                 | 8               |
| 9           | 1001                 | 9               |
| 10          | 1010                 | A               |
| 11          | 1011                 | B               |
| 12          | 1100                 | C               |
| 13          | 1101                 | D               |
| 14          | 1110                 | E               |
| 15          | 1111                 | F               |

### 9.3 ASCII Binário

| **Caractere** | **Decimal** | **Binário** |
| ------------- | ----------- | ----------- |
| NUL           | 0           | 00000000    |
| LF            | 10          | 00001010    |
| CR            | 13          | 00001101    |
| SPACE         | 32          | 00100000    |
| 0             | 48          | 00110000    |
| A             | 65          | 01000001    |
| a             | 97          | 01100001    |

### 9.4 Operadores Bitwise

| **Operador** | **C/Python** | **Descrição**               |
| ------------ | ------------ | --------------------------- |
| AND          | `&`          | Bit a bit E                 |
| OR           | \`           | \`                          |
| XOR          | `^`          | Bit a bit OU exclusivo      |
| NOT          | `~`          | Bit a bit NÃO (complemento) |
| Left Shift   | `<<`         | Deslocamento à esquerda     |
| Right Shift  | `>>`         | Deslocamento à direita      |

***

## 📚 Conclusão

O sistema binário é a linguagem fundamental dos computadores. Sua simplicidade (apenas dois estados) permite a construção de sistemas digitais confiáveis e escaláveis. Dominar o binário é essencial para:

* **Programação de baixo nível**: Manipulação de bits, otimização de código
* **Segurança da informação**: Análise de malware, engenharia reversa
* **Redes de computadores**: Sub-redes, protocolos, endereçamento
* **Arquitetura de computadores**: Processadores, memória, sistemas de arquivos
* **Ciência de dados**: Representação numérica, algoritmos de compressão

Compreender como os computadores representam e manipulam informações em nível binário permite uma compreensão mais profunda de como sistemas funcionam e como explorá-los de forma eficiente e segura.

***

## 🔗 Referências

### Documentação e Artigos

* [IEEE 754: Floating-Point Arithmetic](https://ieeexplore.ieee.org/document/8766229)
* [RFC 791: Internet Protocol (IPv4)](https://datatracker.ietf.org/doc/html/rfc791)
* [UTF-8 Specification (RFC 3629)](https://datatracker.ietf.org/doc/html/rfc3629)
* [ELF Specification (Tool Interface Standard)](https://refspecs.linuxbase.org/elf/elf.pdf)

### Livros

* **"Code: The Hidden Language of Computer Hardware and Software"** – Charles Petzold
* **"The Art of Assembly Language"** – Randall Hyde
* **"Hacking: The Art of Exploitation"** – Jon Erickson
* **"Computer Organization and Design"** – Patterson & Hennessy

### Ferramentas

* [CyberChef - The Cyber Swiss Army Knife](https://gchq.github.io/CyberChef/)
* [HxD Hex Editor](https://mh-nexus.de/en/hxd/)
* [radare2](https://rada.re/n/)
* [Ghidra](https://ghidra-sre.org/)


---

# 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/sistemas-numericos/binario.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.