# URL Encode

> **Um guia abrangente sobre URL Encoding** – desde os fundamentos da codificação de URLs até aplicações práticas em desenvolvimento web, segurança da informação e análise forense.

***

## 🔍 Introdução ao URL Encoding

### 1.1 O que é URL Encoding?

**URL Encoding** (também conhecido como **Percent Encoding**) é um mecanismo para codificar caracteres especiais em URLs, substituindo-os por uma sequência de escape no formato `%XX`, onde `XX` representa o valor hexadecimal do caractere na codificação ASCII (ou UTF-8).

**Exemplo:**

```
Espaço → %20
@ → %40
/ → %2F
? → %3F
```

Uma URL codificada se parece com:

```
https://example.com/search?q=hello%20world&category=IT%2FSecurity
```

### 1.2 Histórico e Origem

| **Ano**  | **Evento**                                                                        |
| -------- | --------------------------------------------------------------------------------- |
| **1994** | RFC 1738 (Uniform Resource Locators) define a sintaxe básica de URLs              |
| **1998** | RFC 2396 (Uniform Resource Identifiers) introduz o conceito de percent encoding   |
| **2005** | RFC 3986 (Uniform Resource Identifier) padroniza a codificação atual              |
| **2014** | WHATWG Living Standard atualiza a especificação de URLs para navegadores modernos |

### 1.3 Por que Precisamos Codificar URLs?

As URLs têm uma estrutura definida com caracteres reservados para funções específicas:

| **Razão**               | **Descrição**                                                    |
| ----------------------- | ---------------------------------------------------------------- |
| **Segurança**           | Evita ambiguidade entre dados e sintaxe da URL                   |
| **Compatibilidade**     | Garante que caracteres especiais sejam transmitidos corretamente |
| **Internacionalização** | Permite caracteres Unicode em URLs (via UTF-8)                   |
| **Protocolos**          | HTTP e outros protocolos exigem caracteres ASCII imprimíveis     |

***

## 📐 Fundamentos Técnicos

### 2.1 Como Funciona: Percent Encoding

O percent encoding substitui um caractere pelo símbolo `%` seguido de dois dígitos hexadecimais (maiúsculos por convenção) que representam o valor do byte.

```
Caractere → Valor ASCII/UTF-8 (hex) → %HH

Exemplos:
Espaço → 20 → %20
! → 21 → %21
@ → 40 → %40
```

### 2.2 Caracteres Seguros e Reservados

**Caracteres Seguros (não precisam ser codificados):**

| **Categoria**  | **Caracteres** |
| -------------- | -------------- |
| **Letras**     | A-Z, a-z       |
| **Dígitos**    | 0-9            |
| **Hífen**      | -              |
| **Ponto**      | .              |
| **Sublinhado** | \_             |
| **Til**        | \~             |

**Caracteres Reservados (codificados quando usados como dados):**

| **Caractere** | **Função na URL**      | **Codificado** |
| ------------- | ---------------------- | -------------- |
| `:`           | Separa esquema         | `%3A`          |
| `/`           | Separa caminhos        | `%2F`          |
| `?`           | Inicia query string    | `%3F`          |
| `#`           | Inicia fragmento       | `%23`          |
| `[`           | Delimitador IPv6       | `%5B`          |
| `]`           | Delimitador IPv6       | `%5D`          |
| `@`           | Separa usuário do host | `%40`          |
| `!`           | Sub-delimitador        | `%21`          |
| `$`           | Sub-delimitador        | `%24`          |
| `&`           | Separa parâmetros      | `%26`          |
| `'`           | Sub-delimitador        | `%27`          |
| `(`           | Sub-delimitador        | `%28`          |
| `)`           | Sub-delimitador        | `%29`          |
| `*`           | Sub-delimitador        | `%2A`          |
| `+`           | Espaço (em query)      | `%2B`          |
| `,`           | Sub-delimitador        | `%2C`          |
| `;`           | Sub-delimitador        | `%3B`          |
| `=`           | Separa chave/valor     | `%3D`          |

### 2.3 Tabela de Caracteres Codificados

| **Caractere** | **Codificação** | **Caractere** | **Codificação** |
| ------------- | --------------- | ------------- | --------------- |
| Espaço        | `%20`           | `!`           | `%21`           |
| `"`           | `%22`           | `#`           | `%23`           |
| `$`           | `%24`           | `%`           | `%25`           |
| `&`           | `%26`           | `'`           | `%27`           |
| `(`           | `%28`           | `)`           | `%29`           |
| `*`           | `%2A`           | `+`           | `%2B`           |
| `,`           | `%2C`           | `-`           | (seguro)        |
| `.`           | (seguro)        | `/`           | `%2F`           |
| `:`           | `%3A`           | `;`           | `%3B`           |
| `<`           | `%3C`           | `=`           | `%3D`           |
| `>`           | `%3E`           | `?`           | `%3F`           |
| `@`           | `%40`           | `[`           | `%5B`           |
| `\`           | `%5C`           | `]`           | `%5D`           |
| `^`           | `%5E`           | `_`           | (seguro)        |
| `` ` ``       | `%60`           | `{`           | `%7B`           |
| \`            | \`              | `%7C`         | `}`             |
| `~`           | (seguro)        |               |                 |

### 2.4 Diferença entre URI, URL e URN

```
URI (Uniform Resource Identifier)
├── URL (Uniform Resource Locator) – localização
│   └── https://example.com/path?query#fragment
└── URN (Uniform Resource Name) – nome
    └── urn:isbn:0451450523
```

***

## 🧩 Componentes da URL e Codificação

### 3.1 Esquema (Scheme)

O esquema indica o protocolo a ser utilizado (http, https, ftp, etc.).

```
https://example.com/path
```

**Caracteres permitidos:** A-Z, a-z, 0-9, `+`, `-`, `.`

### 3.2 Autoridade (Authority)

Inclui usuário, senha, host e porta.

```
https://usuario:senha@example.com:8080/path
```

| **Componente** | **Codificação Necessária**          |
| -------------- | ----------------------------------- |
| Usuário        | `@`, `:`, `/`, `#`, `?`             |
| Senha          | `@`, `:`, `/`, `#`, `?`             |
| Host           | Para IPv6, `[` e `]` são permitidos |
| Porta          | Apenas dígitos                      |

### 3.3 Caminho (Path)

O caminho é hierárquico, com segmentos separados por `/`.

```
/path/to/resource
```

**Caracteres reservados no caminho:** `/`, `?`, `#`, `[`, `]`

### 3.4 Query String

A query string contém parâmetros no formato `chave=valor`, separados por `&`.

```
?q=hello&page=1&sort=desc
```

**Caracteres reservados na query:** `&`, `=`, `?`, `#`, `+`, `;`

### 3.5 Fragmento (Fragment)

O fragmento identifica uma parte secundária do recurso.

```
#section1
```

**Caracteres reservados no fragmento:** `#`, `?`, `[`, `]`

***

## 🔄 Variações e Contextos

### 4.1 application/x-www-form-urlencoded

É o formato padrão usado em formulários HTML enviados via POST (e também GET). Possui uma diferença importante:

| **Contexto**        | **Codificação do Espaço** |
| ------------------- | ------------------------- |
| **URL normal**      | `%20`                     |
| **Formulário POST** | `+`                       |

**Exemplo:**

```
Texto: "hello world"
URL: https://example.com?q=hello%20world
Form POST: q=hello+world
```

### 4.2 Codificação em HTML e JavaScript

Diferentes contextos exigem diferentes níveis de codificação:

| **Contexto**          | **Exemplo**                  | **Codificação Necessária**            |
| --------------------- | ---------------------------- | ------------------------------------- |
| **HTML Attribute**    | `<a href="url">`             | URL encode                            |
| **JavaScript String** | `window.location = "url"`    | JavaScript string escape + URL encode |
| **CSS**               | `background-image: url(...)` | URL encode                            |
| **JSON**              | `{"url": "..."}`             | JSON string escape + URL encode       |

### 4.3 Double Encoding

A codificação dupla ocorre quando um caractere é codificado, e depois o resultado é codificado novamente.

```
Espaço → %20 → %2520
/ → %2F → %252F
```

**Uso em ataques:** Evasão de WAFs que decodificam apenas uma vez.

### 4.4 Unicode e UTF-8 em URLs

Caracteres não-ASCII devem ser codificados usando seus bytes UTF-8.

| **Caractere** | **UTF-8 (hex)** | **URL Encoded** |
| ------------- | --------------- | --------------- |
| `ç`           | C3 A7           | `%C3%A7`        |
| `ã`           | C3 A3           | `%C3%A3`        |
| `á`           | C3 A1           | `%C3%A1`        |
| `ñ`           | C3 B1           | `%C3%B1`        |
| `€`           | E2 82 AC        | `%E2%82%AC`     |
| `😀`          | F0 9F 98 80     | `%F0%9F%98%80`  |

***

## 🎯 Aplicações Práticas do URL Encoding

### 5.1 Formulários Web e GET/POST

Quando um formulário HTML é enviado via GET, os dados são codificados na URL.

```html
<form method="GET" action="/search">
    <input name="q" value="hello world">
    <input name="category" value="IT/Security">
    <button type="submit">Buscar</button>
</form>
```

**Resultado:** `/search?q=hello+world&category=IT%2FSecurity`

### 5.2 APIs RESTful

APIs REST frequentemente recebem parâmetros na URL que precisam ser codificados.

```javascript
// Exemplo de chamada API
fetch(`/api/users/${encodeURIComponent(userName)}/documents/${encodeURIComponent(docId)}`)
```

### 5.3 Redirecionamentos e Parâmetros

Parâmetros passados em redirecionamentos devem ser codificados.

```php
// PHP
header("Location: /page?return_url=" . urlencode($returnUrl));
```

### 5.4 Cookies e Cabeçalhos HTTP

Cookies e cabeçalhos HTTP também exigem codificação de caracteres especiais.

```
Set-Cookie: name=value%20with%20space
```

### 5.5 Ofuscação em Ataques Web

Atacantes usam URL encoding para ofuscar payloads maliciosos.

```http
GET /search?q=%3Cscript%3Ealert%281%29%3C%2Fscript%3E HTTP/1.1
```

**Decodificado:** `<script>alert(1)</script>`

### 5.6 Evasão de Filtros (WAF Bypass)

Técnicas de evasão com URL encoding:

| **Técnica**             | **Exemplo**                         |
| ----------------------- | ----------------------------------- |
| **Codificação simples** | `%3Cscript%3E`                      |
| **Codificação dupla**   | `%253Cscript%253E`                  |
| **Codificação mista**   | `%3Cscript%3C%73%63%72%69%70%74%3E` |
| **Unicode overlong**    | `%C0%BCscript%3E`                   |

***

## 💻 URL Encoding em Programação

### 6.1 JavaScript

```javascript
// Codificação (URI)
encodeURI("https://example.com/search?q=hello world")
// "https://example.com/search?q=hello%20world"

// Codificação de componente (mais agressiva)
encodeURIComponent("hello world?=value")
// "hello%20world%3F%3Dvalue"

// Decodificação
decodeURI("hello%20world")        // "hello world"
decodeURIComponent("hello%20world%3F") // "hello world("")]

// Para formulários (espaço como +)
function encodeForm(str) {
    return encodeURIComponent(str).replace(/%20/g, '+');
}
```

### 6.2 Python

```python
import urllib.parse

# Codificação
urllib.parse.quote("hello world")          # "hello%20world"
urllib.parse.quote_plus("hello world")     # "hello+world"

# Codificação segura (evita codificar caracteres seguros)
urllib.parse.quote("hello world", safe='')

# Codificação de componente
urllib.parse.quote_plus("hello?=world")    # "hello%3F%3Dworld"

# Decodificação
urllib.parse.unquote("hello%20world")      # "hello world"
urllib.parse.unquote_plus("hello+world")   # "hello world"

# URL completa
from urllib.parse import urlencode
params = {'q': 'hello world', 'page': '1'}
urlencode(params)  # "q=hello+world&page=1"
```

### 6.3 PHP

```php
<?php
// Codificação
urlencode("hello world");        // "hello+world"
rawurlencode("hello world");     // "hello%20world"

// Para URLs (RFC 3986) - recomendado
rawurlencode("hello world");     // "hello%20world"

// Decodificação
urldecode("hello+world");        // "hello world"
rawurldecode("hello%20world");   // "hello world"

// Construção de query string
http_build_query(['q' => 'hello world', 'page' => 1]);
// "q=hello+world&page=1"
?>
```

### 6.4 Java

```java
import java.net.URLEncoder;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;

public class URLEncodeExample {
    public static void main(String[] args) throws Exception {
        // Codificação
        String encoded = URLEncoder.encode("hello world", StandardCharsets.UTF_8);
        System.out.println(encoded);  // "hello+world"
        
        // Para uso em URL (espaço como %20)
        String rawEncoded = URLEncoder.encode("hello world", StandardCharsets.UTF_8)
            .replace("+", "%20");
        
        // Decodificação
        String decoded = URLDecoder.decode(encoded, StandardCharsets.UTF_8);
        System.out.println(decoded);  // "hello world"
    }
}
```

### 6.5 C#/.NET

```csharp
using System;
using System.Net;
using System.Web;

class Program {
    static void Main() {
        // Codificação (para URLs)
        string encoded = WebUtility.UrlEncode("hello world");
        Console.WriteLine(encoded);  // "hello%20world"
        
        // Para formulários (espaço como +)
        string formEncoded = Uri.EscapeDataString("hello world");
        Console.WriteLine(formEncoded);  // "hello%20world"
        
        // Decodificação
        string decoded = WebUtility.UrlDecode(encoded);
        Console.WriteLine(decoded);  // "hello world"
    }
}
```

### 6.6 Go

```go
package main

import (
    "fmt"
    "net/url"
)

func main() {
    // Codificação
    encoded := url.QueryEscape("hello world")
    fmt.Println(encoded)  // "hello%20world"
    
    // Decodificação
    decoded, _ := url.QueryUnescape(encoded)
    fmt.Println(decoded)  // "hello world"
    
    // Construção de query
    params := url.Values{}
    params.Add("q", "hello world")
    params.Add("page", "1")
    fmt.Println(params.Encode())  // "q=hello+world&page=1"
}
```

### 6.7 Ruby

```ruby
require 'uri'

# Codificação
URI.encode_www_form_component("hello world")  # "hello+world"
URI.encode_www_form([["q", "hello world"]])   # "q=hello+world"

# Para URLs (RFC 3986)
URI::DEFAULT_PARSER.escape("hello world")     # "hello%20world"

# Decodificação
URI.decode_www_form_component("hello%20world") # "hello world"
```

### 6.8 Bash/Linux

```bash
# Codificação via Python
python3 -c "import urllib.parse; print(urllib.parse.quote('hello world'))"
# hello%20world

# Codificação via printf e xxd
printf "hello world" | xxd -p | sed 's/\(..\)/%\1/g'
# %68%65%6c%6c%6f%20%77%6f%72%6c%64

# Decodificação via Python
python3 -c "import urllib.parse; print(urllib.parse.unquote('hello%20world'))"

# Ferramenta curl para mostrar URL codificada
curl -G --data-urlencode "q=hello world" "https://example.com/search"
# https://example.com/search?q=hello%20world
```

***

## 🔬 Análise Forense e Segurança

### 7.1 Identificação de URL Encoding em Logs

Em logs de servidores web, atacantes frequentemente usam URL encoding.

```log
192.168.1.100 - - [27/Mar/2025:10:30:45] "GET /search?q=%3Cscript%3Ealert%281%29%3C%2Fscript%3E HTTP/1.1" 200 1234
```

**Análise:**

* `%3C` = `<`
* `%3E` = `>`
* `%28` = `(`
* `%29` = `)`

**Payload decodificado:** `<script>alert(1)</script>`

### 7.2 Decodificação de Ataques

```python
import urllib.parse
import re

def decode_payload(log_line):
    # Extrair query string ou parâmetros
    match = re.search(r'\?.*?=([^&\s]+)', log_line)
    if match:
        encoded = match.group(1)
        decoded = urllib.parse.unquote(encoded)
        return decoded
    return None
```

### 7.3 Técnicas de Ofuscação em Malware

Malware frequentemente usa URL encoding para ofuscar:

* URLs de C2 (Command & Control)
* Parâmetros de exfiltração
* Payloads de segunda etapa

```http
GET /api/data?param=%68%74%74%70%73%3A%2F%2F%65%76%69%6C%2E%63%6F%6D HTTP/1.1
```

**Decodificado:** `https://evil.com`

### 7.4 WAF Bypass e Evasão

Técnicas de evasão comuns:

| **Técnica**                 | **Exemplo**                         |
| --------------------------- | ----------------------------------- |
| **Codificação simples**     | `%27%20or%20%271%27%3D%271`         |
| **Codificação dupla**       | `%2527%20or%20%25271%2527%3D%25271` |
| **Codificação mista**       | `%27%20or%20%25271%2527%3D%25271`   |
| **Codificação com Unicode** | `%uff07` (para `'`)                 |
| **Tab e Newline**           | `%09%0a%0d` entre palavras          |

### 7.5 Phishing e URL Encoding

Links de phishing frequentemente usam URL encoding para ocultar o destino real.

```
https://seguro-banco.com%2Eevil.com/login
```

**Decodificado:** `https://seguro-banco.com.evil.com/login` (domínio real é `evil.com`)

***

## 🛠️ Ferramentas para Trabalhar com URL Encoding

### 8.1 Comandos de Linha de Comando

```bash
# Usando Python
python3 -c "import urllib.parse; print(urllib.parse.quote('hello world'))"
python3 -c "import urllib.parse; print(urllib.parse.unquote('hello%20world'))"

# Usando Perl
perl -MURI::Escape -e 'print uri_escape("hello world")'
perl -MURI::Escape -e 'print uri_unescape("hello%20world")'

# Usando curl (com --data-urlencode)
curl -G --data-urlencode "q=hello world" https://example.com

# Usando jq para processar JSON
echo '{"url": "hello%20world"}' | jq -r '.url' | python3 -c "import sys, urllib.parse; print(urllib.parse.unquote(sys.stdin.read().strip()))"
```

### 8.2 Ferramentas Online

| **Ferramenta**         | **Descrição**                                    |
| ---------------------- | ------------------------------------------------ |
| **CyberChef**          | Múltiplas operações de codificação/decodificação |
| **URL Decoder**        | Ferramentas simples online                       |
| **Burp Suite Decoder** | Decodificação integrada para testes de segurança |
| **Postman**            | Constrói e codifica URLs automaticamente         |

### 8.3 Ferramentas de Análise Forense

| **Ferramenta** | **Descrição**                                              |
| -------------- | ---------------------------------------------------------- |
| **Burp Suite** | Decodifica parâmetros automaticamente no Repeater/Intruder |
| **OWASP ZAP**  | Decodificação de parâmetros e fuzzing                      |
| **Wireshark**  | Seguir fluxo HTTP e visualizar URLs codificadas            |
| **LogParser**  | Análise de logs com decodificação automática               |

***

## 🔬 Exemplos Práticos

### 9.1 Codificando Parâmetros de Busca

```python
import urllib.parse

def build_search_url(base_url, query, filters=None):
    params = {'q': query}
    if filters:
        params.update(filters)
    
    query_string = urllib.parse.urlencode(params, quote_via=urllib.parse.quote)
    return f"{base_url}?{query_string}"

# Uso
url = build_search_url("https://example.com/search", 
                       "hello world", 
                       {"category": "IT/Security", "sort": "desc"})
print(url)
# https://example.com/search?q=hello%20world&category=IT%2FSecurity&sort=desc
```

### 9.2 Analisando um Payload de Ataque

```python
import urllib.parse

payloads = [
    "%3Cscript%3Ealert%281%29%3C%2Fscript%3E",
    "%3Cimg%20src%3Dx%20onerror%3Dalert%281%29%3E",
    "%27%20or%20%271%27%3D%271",
    "%3Csvg%20onload%3Dalert%281%29%3E"
]

for payload in payloads:
    decoded = urllib.parse.unquote(payload)
    print(f"Encoded: {payload}")
    print(f"Decoded: {decoded}")
    print("-" * 40)
```

### 9.3 Decodificando um Link de Phishing

```python
import urllib.parse

# Link de phishing suspeito
suspicious_url = "https://secure-login.com%2Faccount%2Fverify%3Fredirect%3Dhttps%253A%252F%252Fevil.com"

# Decodificar uma vez
first_decode = urllib.parse.unquote(suspicious_url)
print(f"First decode: {first_decode}")

# Decodificar duas vezes (double encoding)
second_decode = urllib.parse.unquote(first_decode)
print(f"Second decode: {second_decode}")
```

### 9.4 WAF Bypass com Codificação Dupla

```python
import urllib.parse

# Payload original
payload = "<script>alert(1)</script>"

# Codificação simples
simple = urllib.parse.quote(payload)
print(f"Single: {simple}")

# Codificação dupla
double = urllib.parse.quote(simple)
print(f"Double: {double}")

# Testar se decodificação dupla restaura original
test = urllib.parse.unquote(urllib.parse.unquote(double))
print(f"Restored: {test}")
```

### 9.5 Extraindo URLs Codificadas de Logs

```bash
# Extrair e decodificar parâmetros de logs
grep -oP 'q=\K[^&\s]+' access.log | while read line; do
    echo -n "Encoded: $line -> "
    python3 -c "import urllib.parse; print(urllib.parse.unquote('$line'))"
done
```

***

## 📊 Tabelas de Referência Rápida

### 10.1 Caracteres Reservados e Suas Codificações

| **Caractere** | **Codificação** | **Função na URL**        |
| ------------- | --------------- | ------------------------ |
| `:`           | `%3A`           | Separador de esquema     |
| `/`           | `%2F`           | Separador de caminho     |
| `?`           | `%3F`           | Início da query string   |
| `#`           | `%23`           | Início do fragmento      |
| `[`           | `%5B`           | Delimitador IPv6         |
| `]`           | `%5D`           | Delimitador IPv6         |
| `@`           | `%40`           | Separador de credenciais |
| `!`           | `%21`           | Sub-delimitador          |
| `$`           | `%24`           | Sub-delimitador          |
| `&`           | `%26`           | Separador de parâmetros  |
| `'`           | `%27`           | Sub-delimitador          |
| `(`           | `%28`           | Sub-delimitador          |
| `)`           | `%29`           | Sub-delimitador          |
| `*`           | `%2A`           | Sub-delimitador          |
| `+`           | `%2B`           | Espaço (formulário)      |
| `,`           | `%2C`           | Sub-delimitador          |
| `;`           | `%3B`           | Sub-delimitador          |
| `=`           | `%3D`           | Separador de chave/valor |

### 10.2 Caracteres Não-ASCII Comuns

| **Caractere** | **UTF-8 (hex)** | **URL Encoded** |
| ------------- | --------------- | --------------- |
| `á`           | C3 A1           | `%C3%A1`        |
| `é`           | C3 A9           | `%C3%A9`        |
| `í`           | C3 AD           | `%C3%AD`        |
| `ó`           | C3 B3           | `%C3%B3`        |
| `ú`           | C3 BA           | `%C3%BA`        |
| `ñ`           | C3 B1           | `%C3%B1`        |
| `ç`           | C3 A7           | `%C3%A7`        |
| `€`           | E2 82 AC        | `%E2%82%AC`     |
| `£`           | C2 A3           | `%C2%A3`        |
| `¥`           | C2 A5           | `%C2%A5`        |

### 10.3 Comparação de Funções de Codificação

| **Linguagem** | **Função (espaço → %20)**                 | **Função (espaço → +)**                     |
| ------------- | ----------------------------------------- | ------------------------------------------- |
| JavaScript    | `encodeURIComponent`                      | `encodeURIComponent().replace(/%20/g, '+')` |
| Python        | `urllib.parse.quote`                      | `urllib.parse.quote_plus`                   |
| PHP           | `rawurlencode`                            | `urlencode`                                 |
| Java          | `URLEncoder.encode().replace('+', '%20')` | `URLEncoder.encode`                         |
| Go            | `url.QueryEscape`                         | `url.QueryEscape` (usa %20)                 |

### 10.4 Tabela ASCII para URL Encoding

| **Dec** | **Hex** | **Char** | **Enc**  | **Dec** | **Hex** | **Char** | **Enc**  |
| ------- | ------- | -------- | -------- | ------- | ------- | -------- | -------- |
| 32      | 20      | espaço   | %20      | 64      | 40      | @        | %40      |
| 33      | 21      | !        | %21      | 65-90   | 41-5A   | A-Z      | (seguro) |
| 34      | 22      | "        | %22      | 91      | 5B      | \[       | %5B      |
| 35      | 23      | #        | %23      | 92      | 5C      | \\       | %5C      |
| 36      | 24      | $        | %24      | 93      | 5D      | ]        | %5D      |
| 37      | 25      | %        | %25      | 94      | 5E      | ^        | %5E      |
| 38      | 26      | &        | %26      | 95      | 5F      | \_       | (seguro) |
| 39      | 27      | '        | %27      | 96      | 60      | \`       | %60      |
| 40      | 28      | (        | %28      | 97-122  | 61-7A   | a-z      | (seguro) |
| 41      | 29      | )        | %29      | 123     | 7B      | {        | %7B      |
| 42      | 2A      | \*       | %2A      | 124     | 7C      | \|       | `%7C`    |
| 43      | 2B      | +        | %2B      | 125     | 7D      | }        | %7D      |
| 44      | 2C      | ,        | %2C      | 126     | 7E      | \~       | (seguro) |
| 45-57   | 2D-39   | - 0-9    | (seguro) |         |         |          |          |

***

## 📚 Conclusão

O URL Encoding (Percent Encoding) é um mecanismo fundamental para a transmissão segura de dados na web. Sua compreensão é essencial para:

**Para Desenvolvedores:**

* Construir URLs válidas e seguras
* Processar corretamente dados de formulários
* Criar APIs RESTful robustas

**Para Profissionais de Segurança:**

* Analisar logs e identificar ataques
* Decodificar payloads maliciosos
* Compreender técnicas de WAF bypass

**Para Analistas Forenses:**

* Extrair evidências de logs HTTP
* Decodificar parâmetros em URLs suspeitas
* Rastrear atividades maliciosas

**Pontos-chave:**

* ✅ Espaço pode ser `%20` ou `+` (depende do contexto)
* ✅ Caracteres seguros (A-Z, a-z, 0-9, -, ., \_, \~) não precisam ser codificados
* ⚠️ Codificação dupla pode ser usada para evasão de filtros
* ⚠️ UTF-8 é o padrão para caracteres não-ASCII

***

## 🔗 Referências

### RFCs e Padrões

* [RFC 3986: Uniform Resource Identifier (URI)](https://datatracker.ietf.org/doc/html/rfc3986)
* [RFC 1738: Uniform Resource Locators (URL)](https://datatracker.ietf.org/doc/html/rfc1738)
* [WHATWG URL Standard](https://url.spec.whatwg.org/)

### Documentação Oficial

* [MDN Web Docs: encodeURIComponent](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent)
* [Python urllib.parse Documentation](https://docs.python.org/3/library/urllib.parse.html)
* [PHP urlencode/rawurlencode](https://www.php.net/manual/en/function.urlencode.php)

### Ferramentas

* [CyberChef – URL Encode/Decode](https://gchq.github.io/CyberChef/)
* [Burp Suite Decoder](https://portswigger.net/burp/documentation/desktop/tools/decoder)
* [OWASP ZAP](https://www.zaproxy.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/criptografia/encodagem-encoding/url-encode.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.