# Exadecimal

> **Um guia abrangente sobre o sistema hexadecimal** – 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 Hexadecimal

### 1.1 O que é Hexadecimal?

O **sistema hexadecimal** (base 16) é um sistema de numeração posicional que utiliza **16 símbolos** para representar valores:

| **Símbolo** | **Valor Decimal** |
| ----------- | ----------------- |
| 0 - 9       | 0 a 9             |
| A           | 10                |
| B           | 11                |
| C           | 12                |
| D           | 13                |
| E           | 14                |
| F           | 15                |

O nome "hexadecimal" vem do grego *hexa* (seis) e do latim *decem* (dez), significando "dezesseis". É também chamado de "base 16" ou, informalmente, "hex".

### 1.2 Por que Usamos Hexadecimal?

O hexadecimal é amplamente utilizado em computação porque **cada dígito hexadecimal representa exatamente 4 bits** (meio byte ou nibble). Isso torna a representação de dados binários muito mais compacta e legível para humanos.

| **Quantidade de Bits** | **Representação Binária**               | **Representação Hexadecimal** |
| ---------------------- | --------------------------------------- | ----------------------------- |
| 4 bits                 | 1101                                    | D                             |
| 8 bits (1 byte)        | 1101 1010                               | DA                            |
| 16 bits (2 bytes)      | 1101 1010 1111 0001                     | DAF1                          |
| 32 bits (4 bytes)      | 1101 1010 1111 0001 0010 1100 1011 0110 | DAF12CB6                      |

**Vantagens do Hexadecimal:**

* **Compacto**: Um byte (8 bits) é representado por apenas 2 caracteres hexadecimais
* **Legível**: Mais fácil para humanos lerem "FF" do que "11111111"
* **Preciso**: Mantém correspondência direta com a representação binária
* **Universal**: Usado em programação, depuração, análise forense, redes e design

## 📐 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₁₀

#### Sistema Hexadecimal (Base 16)

* **Símbolos**: 0-9, A-F (A=10, B=11, C=12, D=13, E=14, F=15)
* **Posições**: ... 16³, 16², 16¹, 16⁰
* **Exemplo**: 2F₁₆ = (2 × 16¹) + (15 × 16⁰) = 32 + 15 = 47₁₀

### 2.2 Conversões entre Sistemas

#### Decimal para Hexadecimal

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

**Exemplo:** Converter 245₁₀ para hexadecimal

| Passo | Divisão  | Quociente | Resto (Hex) |
| ----- | -------- | --------- | ----------- |
| 1     | 245 ÷ 16 | 15        | 5           |
| 2     | 15 ÷ 16  | 0         | 15 (F)      |

Lendo os restos de baixo para cima: **F5₁₆**

**Verificação:** F5₁₆ = (15 × 16¹) + (5 × 16⁰) = 240 + 5 = 245₁₀ ✅

#### Binário para Hexadecimal

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

| Grupo de 4 bits | Valor Hexadecimal |
| --------------- | ----------------- |
| 0000            | 0                 |
| 0001            | 1                 |
| 0010            | 2                 |
| 0011            | 3                 |
| 0100            | 4                 |
| 0101            | 5                 |
| 0110            | 6                 |
| 0111            | 7                 |
| 1000            | 8                 |
| 1001            | 9                 |
| 1010            | A                 |
| 1011            | B                 |
| 1100            | C                 |
| 1101            | D                 |
| 1110            | E                 |
| 1111            | F                 |

**Exemplo:** Converter 11010110₂ para hexadecimal

```
1101 0110  (agrupar em nibbles)
  D    6   (converter cada nibble)
Resultado: D6₁₆
```

#### Hexadecimal para Binário

**Método:** Converter cada dígito hexadecimal em seu equivalente de 4 bits

**Exemplo:** Converter 3A₁₆ para binário

```
3 = 0011
A = 1010
Resultado: 00111010₂
```

### 2.3 Operações Aritméticas em Hexadecimal

#### Adição

| Regra                                              | Exemplo                           |
| -------------------------------------------------- | --------------------------------- |
| Somar como decimal, converter quando ultrapassar F | 5 + 5 = A                         |
| Carry quando soma ≥ 16                             | F + 3 = 12 (carry 1, resultado 2) |

**Exemplo:** A5₁₆ + 2C₁₆

```
   A 5
+  2 C
--------
   D 1

Passo 1: 5 + C = 5 + 12 = 17 → 17 - 16 = 1, carry 1
Passo 2: A + 2 + 1 = 10 + 2 + 1 = 13 → D
Resultado: D1₁₆
```

#### Subtração

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

**Exemplo:** D1₁₆ - 2C₁₆

```
   D 1
-  2 C
--------
   A 5

Passo 1: 1 não pode subtrair C → empresta 1 do D (que vira C)
        1 + 16 = 17; 17 - 12 = 5
Passo 2: D - 2 = 13 - 2 = 11 → B (mas emprestamos 1, então 12 - 2 = 10 → A)
Resultado: A5₁₆
```

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

### 3.1 Bytes e Nibbles

| **Unidade** | **Bits** | **Representação Hexadecimal**     |
| ----------- | -------- | --------------------------------- |
| **Bit**     | 1        | 0 ou 1                            |
| **Nibble**  | 4        | 1 dígito hex (0-F)                |
| **Byte**    | 8        | 2 dígitos hex (00-FF)             |
| **Word**    | 16 (x86) | 4 dígitos hex (0000-FFFF)         |
| **DWORD**   | 32       | 8 dígitos hex (00000000-FFFFFFFF) |
| **QWORD**   | 64       | 16 dígitos hex                    |

**Relação fundamental:**

```
1 Byte = 8 bits = 2 dígitos hexadecimais
```

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

**Endianness** é a ordem em que os bytes são armazenados na memória.

| **Endianness**    | **Descrição**                     | **Exemplo (valor 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 ("network byte order")
* **Motorola 68k, PowerPC** : Big-Endian

**Exemplo de leitura (Little-Endian):**

```
Na memória:  [78] [56] [34] [12]
Lido como:  0x12 0x34 0x56 0x78
Valor real: 0x12345678
```

### 3.3 Notação Hexadecimal em Diferentes Linguagens

| **Linguagem**  | **Notação**               | **Exemplo**       |
| -------------- | ------------------------- | ----------------- |
| **C/C++**      | `0x` prefix               | `int x = 0x2F;`   |
| **Python**     | `0x` prefix               | `x = 0x2F`        |
| **JavaScript** | `0x` prefix               | `let x = 0x2F;`   |
| **Java**       | `0x` prefix               | `int x = 0x2F;`   |
| **Rust**       | `0x` prefix               | `let x = 0x2F;`   |
| **Go**         | `0x` prefix               | `x := 0x2F`       |
| **Ruby**       | `0x` prefix               | `x = 0x2F`        |
| **PHP**        | `0x` prefix               | `$x = 0x2F;`      |
| **Swift**      | `0x` prefix               | `let x = 0x2F`    |
| **Kotlin**     | `0x` prefix               | `val x = 0x2F`    |
| **Assembly**   | `h` suffix ou `0x` prefix | `MOV AX, 2Fh`     |
| **CSS**        | `#` prefix                | `color: #FF0000;` |

**Funções de conversão:**

```python
# Python
hex(47)          # '0x2f'
int('2f', 16)    # 47

# JavaScript
(47).toString(16)   # '2f'
parseInt('2f', 16)  # 47

# C/C++
printf("%x", 47);   // "2f"
strtol("2f", NULL, 16); // 47

# PowerShell
'{0:X}' -f 47   # "2F"
[Convert]::ToString(47, 16)  # "2f"
```

## 🎯 Aplicações Práticas do Hexadecimal

### 4.1 Cores em Design Digital

Em design web e gráfico, cores são representadas por **6 dígitos hexadecimais** (RGB) ou **8 dígitos** (RGBA com transparência).

| **Formato**  | **Estrutura** | **Exemplo**                  |
| ------------ | ------------- | ---------------------------- |
| **RGB Hex**  | `#RRGGBB`     | `#FF0000` = Vermelho puro    |
| **RGBA Hex** | `#RRGGBBAA`   | `#FF0000FF` = Vermelho opaco |

**Exemplos de cores:**

| **Cor**  | **Hex**   | **RGB**         |
| -------- | --------- | --------------- |
| Preto    | `#000000` | (0, 0, 0)       |
| Branco   | `#FFFFFF` | (255, 255, 255) |
| Vermelho | `#FF0000` | (255, 0, 0)     |
| Verde    | `#00FF00` | (0, 255, 0)     |
| Azul     | `#0000FF` | (0, 0, 255)     |
| Amarelo  | `#FFFF00` | (255, 255, 0)   |
| Ciano    | `#00FFFF` | (0, 255, 255)   |
| Magenta  | `#FF00FF` | (255, 0, 255)   |

### 4.2 Endereços de Memória

Em sistemas computacionais, endereços de memória são representados em hexadecimal.

```c
// C - endereço de memória
int x = 42;
printf("%p", &x);  // Saída: 0x7fff5fbff5c8
```

```python
# Python - id() retorna endereço em decimal
x = 42
hex(id(x))  # '0x7fff5fbff5c8'
```

### 4.3 Endereços MAC e IPv6

**Endereço MAC (6 bytes):**

* Formato: `XX:XX:XX:XX:XX:XX` (cada XX é 1 byte em hex)
* Exemplo: `00:1A:2B:3C:4D:5E`

**IPv6 (128 bits = 16 bytes):**

* Formato: 8 grupos de 4 dígitos hex
* Exemplo: `2001:0db8:85a3:0000:0000:8a2e:0370:7334`
* Compressão: `2001:db8:85a3::8a2e:370:7334`

### 4.4 Mágica de Arquivos (File Signatures)

Cada formato de arquivo possui um **magic number** (assinatura) nos primeiros bytes, normalmente em hexadecimal.

| **Formato**      | **Assinatura (Hex)**      | **ASCII**   |
| ---------------- | ------------------------- | ----------- |
| **PDF**          | `25 50 44 46`             | `%PDF`      |
| **PNG**          | `89 50 4E 47 0D 0A 1A 0A` | `‰PNG....`  |
| **JPEG**         | `FF D8 FF`                | (não ASCII) |
| **ZIP**          | `50 4B 03 04`             | `PK..`      |
| **ELF (Linux)**  | `7F 45 4C 46`             | `ELF`      |
| **PE (Windows)** | `4D 5A`                   | `MZ`        |
| **GIF**          | `47 49 46 38`             | `GIF8`      |
| **MP3 (ID3)**    | `49 44 33`                | `ID3`       |

**Uso forense:** Identificar tipos de arquivo mesmo sem extensão.

### 4.5 Debugging e Engenharia Reversa

Em debuggers e disassemblers, códigos de operação (opcodes) são exibidos em hexadecimal.

**Exemplo (x86 assembly):**

```
0x401000: 55          push ebp
0x401001: 89 E5       mov ebp, esp
0x401003: 83 EC 08    sub esp, 0x8
0x401006: B8 01 00 00 00  mov eax, 0x1
0x40100B: C9          leave
0x40100C: C3          ret
```

### 4.6 Criptografia e Hashes

Hashes criptográficos são representados como strings hexadecimais.

| **Hash**    | **Exemplo**                                                        |
| ----------- | ------------------------------------------------------------------ |
| **MD5**     | `5d41402abc4b2a76b9719d911017c592`                                 |
| **SHA-1**   | `aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d`                         |
| **SHA-256** | `2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824` |

**Uso forense:** Identificar arquivos maliciosos por hash.

## 🛠️ Ferramentas para Trabalhar com Hexadecimal

### 5.1 Editores Hexadecimais (Hex Editors)

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

### 5.2 Calculadoras e Conversores

| **Ferramenta**         | **Descrição**                                       |
| ---------------------- | --------------------------------------------------- |
| **Windows Calculator** | Modo Programador com conversões (base 2, 8, 10, 16) |
| **Python REPL**        | `hex()`, `int('ff', 16)`                            |
| **CyberChef**          | Ferramenta online para conversões e transformações  |
| **RapidTables**        | Conversores online simples                          |

### 5.3 Comandos de Linha de Comando

```bash
# Linux/macOS - converter decimal para hex
printf "%x\n" 255        # ff
echo "obase=16; 255" | bc   # FF

# Linux/macOS - converter hex para decimal
printf "%d\n" 0xFF       # 255
echo $((0xFF))           # 255

# Visualizar arquivo em hex
xxd arquivo.bin          # hexdump
xxd -r arquivo.hex       # converter hex para binário

# hexdump alternativo
hexdump -C arquivo.bin

# Windows PowerShell
'{0:X}' -f 255           # "FF"
[Convert]::ToString(255, 16)  # "ff"
[Convert]::ToInt32('FF', 16)   # 255
```

## 🔬 Exemplos Práticos

### 6.1 Analisando um Arquivo com Hex Editor

**Cenário:** Identificar o tipo de um arquivo sem extensão

```bash
# Usando xxd
xxd -l 20 arquivo.sem_extensao

# Saída esperada para um PDF:
00000000: 2550 4446 2d31 2e35 0a25 e2e3 cfd3 0a0a  %PDF-1.5.%......
```

**Análise:** Os primeiros bytes `25 50 44 46` correspondem a `%PDF` em ASCII → arquivo PDF.

### 6.2 Modificando um Binário (Hacking Simples)

**Cenário:** Modificar uma mensagem de texto em um binário

```bash
# Visualizar strings no binário
strings programa.exe | grep -i "mensagem"

# Localizar posição da string no binário
xxd programa.exe | grep -i "mensagem"

# Modificar a string (exemplo com sed)
echo "mensagem original" | xxd -p
# Saída: 6d656e736167656d206f726967696e616c

echo "mensagem modificada" | xxd -p
# Saída: 6d656e736167656d206d6f6469666963616461

# Editar com hex editor ou dd
echo -n "6d656e736167656d206d6f6469666963616461" | xxd -p -r | dd of=programa.exe bs=1 seek=12345 conv=notrunc
```

### 6.3 Decodificando uma Cor Hex

**Exemplo:** `#FF8000`

```
FF = 255 (Red)
80 = 128 (Green)
00 = 0   (Blue)

Resultado: RGB(255, 128, 0) = Laranja
```

## 📊 Tabelas de Referência Rápida

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

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

### 7.2 ASCII em Hexadecimal

| **Caractere**        | **Hex** | **Caractere** | **Hex** | **Caractere** | **Hex** |
| -------------------- | ------- | ------------- | ------- | ------------- | ------- |
| NUL (null)           | 00      | SPACE         | 20      | 0             | 30      |
| LF (line feed)       | 0A      | !             | 21      | 1             | 31      |
| CR (carriage return) | 0D      | "             | 22      | 2             | 32      |
| ESC                  | 1B      | #             | 23      | 3             | 33      |
|                      |         | $             | 24      | A             | 41      |
|                      |         | %             | 25      | B             | 42      |
|                      |         | &             | 26      | a             | 61      |
|                      |         | '             | 27      | b             | 62      |

### 7.3 File Signatures Comuns (Magic Numbers)

| **Formato**  | **Hex (início)**      | **Extensão**             |
| ------------ | --------------------- | ------------------------ |
| PDF          | `25 50 44 46`         | `.pdf`                   |
| PNG          | `89 50 4E 47`         | `.png`                   |
| JPEG         | `FF D8 FF`            | `.jpg`, `.jpeg`          |
| GIF          | `47 49 46 38`         | `.gif`                   |
| ZIP          | `50 4B 03 04`         | `.zip`, `.docx`, `.xlsx` |
| RAR          | `52 61 72 21`         | `.rar`                   |
| ELF          | `7F 45 4C 46`         | (executável Linux)       |
| PE (EXE/DLL) | `4D 5A`               | `.exe`, `.dll`           |
| Mach-O       | `CF FA ED FE`         | (executável macOS)       |
| MP3          | `49 44 33` ou `FF FB` | `.mp3`                   |
| WAV          | `52 49 46 46`         | `.wav`                   |

## 📚 Conclusão

O sistema hexadecimal é uma ferramenta fundamental em computação, conectando o mundo binário dos computadores à compreensão humana. Sua capacidade de representar 4 bits com um único dígito torna-o ideal para:

* **Programação de baixo nível**: Endereços de memória, operações bit a bit
* **Análise forense**: Identificação de tipos de arquivo, análise de dados
* **Engenharia reversa**: Debugging, análise de malware
* **Redes**: Endereços MAC, IPv6, cabeçalhos de protocolo
* **Design digital**: Cores, gráficos

Dominar o hexadecimal é essencial para profissionais de segurança da informação, desenvolvedores de sistemas, analistas forenses e qualquer pessoa que trabalhe com tecnologia em nível mais profundo.

## 🔗 Referências

### Documentação e Artigos

* [IEEE 754: Floating-Point Arithmetic](https://ieeexplore.ieee.org/document/8766229)
* [RFC 2460: Internet Protocol, Version 6 (IPv6)](https://datatracker.ietf.org/doc/html/rfc2460)
* [File Signatures (Magic Numbers)](https://en.wikipedia.org/wiki/List_of_file_signatures)

### Ferramentas

* [CyberChef - The Cyber Swiss Army Knife](https://gchq.github.io/CyberChef/)
* [HxD Hex Editor](https://mh-nexus.de/en/hxd/)
* [ImHex - A Hex Editor for Reverse Engineers](https://imhex.werwolv.net/)

### Livros

* **"The Art of Assembly Language"** – Randall Hyde
* **"Practical Binary Analysis"** – Dennis Andriesse
* **"Hacking: The Art of Exploitation"** – Jon Erickson


---

# 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/exadecimal.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.