# Intruso

> Intruso do CatSuite: como usar e configurar os marcadores de payload, wordlists, geradores, ritmo do ataque e filtro de resultados por status e tamanho.

- Idioma: pt-BR
- URL canônica: https://netcattest.com/catsuite/docs/modulos/intruso
- Seção: Módulos
- Atualizado: 2026-10-06
- Outro idioma (en): https://netcattest.com/catsuite/en/docs/modules/intruder

O **Intruso** é o módulo de automação de requisições do CatSuite: ele pega uma **request-base**, substitui as **posições marcadas** por cada **payload** de uma wordlist ou de um gerador, dispara os envios no ritmo que você definir e guarda cada resposta para você **recortar e filtrar**. É a ferramenta certa para enumeração de valores, teste de parâmetros, fuzzing controlado e verificação de comportamento quando você precisa repetir a mesma request dezenas ou milhares de vezes trocando apenas um trecho. Esta página explica cada conceito, cada opção e como configurar o Intruso passo a passo, sempre contra um alvo autorizado.

> [!AVISO]
> O Intruso gera tráfego automatizado real. Use somente contra sistemas que você tem autorização por escrito para testar e mantenha o ritmo responsável. Veja [Segurança e uso responsável](https://netcattest.com/catsuite/docs/seguranca).

## O que é o Intruso e para que serve

O Intruso resolve um problema simples de repetição: em vez de editar e reenviar uma request manualmente no [Repetir](https://netcattest.com/catsuite/docs/modulos/repetir), você marca **onde** o valor muda, escolhe **quais** valores testar e deixa o módulo percorrer a lista inteira. Cada envio vira uma linha no **log da intrusão**, com status, tamanho e tempo, pronta para comparação.

Casos de uso típicos:

- Enumerar identificadores sequenciais (por exemplo `id=1` até `id=500`) para checar controle de acesso.
- Testar uma lista de nomes de usuário, caminhos ou parâmetros contra um endpoint.
- Variar o valor de um header ou de um campo de formulário e observar mudanças de resposta.
- Medir diferenças de tamanho e tempo entre a resposta normal (a **sonda**) e cada variação.

O Intruso é um **cliente HTTP local**: ele monta e envia as requests do próprio aparelho, sem servidores intermediários. O histórico da sessão fica salvo no armazenamento do app, então você pode **pausar e retomar** sem perder o progresso.

## Conceitos essenciais do Intruso

Antes de configurar, vale entender os termos que aparecem na tela. Cada conceito abaixo tem um reflexo direto em um botão ou painel do módulo.

### Marcadores de payload: marcar as posições

Um **marcador de payload** indica o ponto exato da request em que cada valor da sua lista vai entrar. No Intruso você **não digita** o marcador à mão: os botões **AUTODETECTAR** e **MARCAR SELEÇÃO** envolvem o trecho escolhido em um **par de marcadores** e cada posição passa a aparecer como um chip `P1`, `P2`, `P3`… na lista **MARCAÇÕES ATUAIS**. No editor, o trecho marcado fica destacado entre o par de delimitadores (`§valor§`).

> [!NOTA]
> O marcador de payload é a mesma ideia do token `$CAT$` que o [Descobridor](https://netcattest.com/catsuite/docs/modulos/descobridor) usa literalmente na URL. A diferença é que, no Intruso, o marcador é inserido pelos botões ao redor de um trecho existente, em vez de digitado. Para remover todas as marcações, use **LIMPAR** na aba REQUEST.

A detecção automática entende três formatos de campo:

- **Query string** na URL (`?chave=valor&chave2=valor2`).
- **Formulário** `application/x-www-form-urlencoded` no corpo (`campo=valor`).
- **JSON** no corpo (marca os valores de cada par `"chave": valor`).

### Wordlists e geradores de payload

Os valores que entram nas posições vêm de uma de duas **origens**:

- **Wordlist** — uma lista de linhas, interna ou importada por você. As wordlists internas e as criadas nas configurações do app são listadas no seletor **WORDLIST DO INTRUSO**. Importação, formato `.txt` e validação estão detalhados em [Wordlists e payloads](https://netcattest.com/catsuite/docs/modulos/wordlists).
- **Gerador dinâmico** — cria uma sequência numérica na hora, a partir de um intervalo e de afixos. Útil quando você não tem um arquivo, só um intervalo (por exemplo `user-001` a `user-250`).

### Modos de distribuição

Quando há **mais de uma posição marcada**, o **modo de distribuição** decide como as listas são combinadas entre as marcas. São quatro modos, cada um com uma estimativa de total diferente, detalhados na tabela **Modos de distribuição e combinação**, mais abaixo.

### Processadores de payload

Um **processador** é uma transformação aplicada a cada payload **antes** do envio. Você monta uma **cadeia** de passos (codificar em URL, Base64, gerar hash, mudar a caixa, escapar Unicode, adicionar afixos) e os passos são aplicados **na ordem** em que aparecem. É o mesmo mecanismo do [Decodificar](https://netcattest.com/catsuite/docs/modulos/decodificar), reaproveitado para preparar os valores no momento do ataque.

### Sonda e linha de base (baseline)

Ao iniciar, o Intruso envia primeiro a request **sem marcadores** — a **sonda**. A resposta da sonda vira a **linha de base** contra a qual cada variação é comparada. A partir dela o módulo calcula, para cada resultado:

- **Delta de tamanho** — a diferença, em bytes, entre a resposta e a sonda.
- **Semelhança** — um índice de 0 a 100 (por bigramas) entre o corpo da resposta e o da sonda.
- **Diferente da sonda** — se o corpo é igual ou diferente do da linha de base.

### Recorte e filtro de resultados

**Recorte** e **filtro** refinam o que o log mostra, sem reenviar nada. Você pode filtrar por **status**, **tamanho**, **tempo**, buscar por **palavras** em qualquer parte do resultado e aplicar **GREP** (manter o que casa com um padrão) ou **EXTRAIR** (puxar um trecho da resposta via regex).

### Ritmo e sessão

O **ritmo** combina duas opções: o **delay** (espera fixa entre tentativas) e as **requisições por segundo** (teto de taxa). O Intruso respeita o maior intervalo entre os dois. A **sessão** é persistida em disco, então pausar, sair e voltar mantém request, marcações, payloads e resultados.

## A tela do Intruso: páginas, abas e painéis

O Intruso tem duas páginas: **Preparação** (onde você monta o ataque) e **Fluxo** (onde acompanha os resultados). Você alterna entre elas com **VER FLUXO** e com o botão de voltar da página de fluxo.

### Página de preparação

A preparação é dividida em três abas, no topo: **ALVO**, **REQUEST** e **PAYLOADS**. A aba REQUEST mostra um contador com o número de marcações ativas.

### Aba ALVO

Define o destino e a rede. O campo **ALVO PRINCIPAL** aceita um host (`alvo.exemplo`) ou uma URL completa — o Intruso mantém apenas **host, protocolo e porta**, descartando caminho, query e barras extras. Abaixo ficam o **PROTOCOLO** (HTTPS/HTTP), a **PORTA**, o **DELAY**, as **REQUISIÇÕES POR SEGUNDO** e o interruptor de **tolerância TLS**. Os chips do topo resumem a configuração atual (alvo, delay, ritmo e TLS estrito/flexível).

### Aba REQUEST

Contém o editor da request-base e as ações de marcação: **AUTODETECTAR**, **MARCAR SELEÇÃO** e **LIMPAR**. Logo abaixo, **MARCAÇÕES ATUAIS** lista os chips `P1`, `P2`… e um **preview** com as posições destacadas. Quando a request chega importada do [Interceptador](https://netcattest.com/catsuite/docs/modulos/interceptador) ou do [Repetir](https://netcattest.com/catsuite/docs/modulos/repetir), o Intruso já tenta marcar os campos automaticamente.

### Aba PAYLOADS

Reúne, nesta ordem: os **tiles de modo de distribuição**; (quando há duas ou mais marcas em modo Alinhadas ou Combinações) os **chips de origem por marca**; a escolha de **ORIGEM DOS PAYLOADS** (WORDLIST ou GERADOR DINÂMICO); a configuração da origem escolhida; e os **PROCESSADORES**.

### Página de fluxo (resultados)

Mostra três contadores — **PROCESSADAS**, **RESPOSTAS** e **FALHAS** — e o **LOG DA INTRUSÃO**. Cada resultado é um cartão com `#` da execução, status, tamanho, tempo, o payload e um trecho da resposta. O botão **FILTROS** abre o recorte; **LIMPAR** zera os filtros ativos. Toque e segure um resultado para abrir o menu de cópia e envio.

## Opções do Intruso e como configurar

A tabela abaixo reúne as opções de alvo, rede e ritmo da aba ALVO.

| Opção | Valores | Padrão | O que faz |
| --- | --- | --- | --- |
| Protocolo | HTTPS, HTTP | HTTPS | Define o esquema do envio e sugere a porta (443 ou 80) |
| Porta | 1 a 65535 | 443 (HTTPS) / 80 (HTTP) | Porta de destino; some do header `Host` quando é a padrão do protocolo |
| Alvo principal | host ou URL | vazio | Destino do ataque; mantém só host, protocolo e porta |
| Delay | 0, 50, 100, 250, 500, 750, 1000 ms | 0 (sem delay) | Espera fixa antes de iniciar a próxima tentativa (aceita 0 a 60000) |
| Requisições por segundo | 0, 1, 2, 3, 5, 10, 20 | 0 (livre) | Teto de taxa; 0 não limita e respeita só o delay (aceita 0 a 1000) |
| Ignorar erros de certificado | Ligado, Desligado | Desligado (TLS estrito) | Aceita certificados TLS inválidos ou autoassinados |

Para **configurar o alvo**, cole o host ou a URL no campo ALVO PRINCIPAL; se colar uma URL com protocolo e porta, o Intruso ajusta os botões e o campo automaticamente. Escolha **HTTPS** ou **HTTP** — ao trocar, a porta padrão (443/80) é preenchida quando o campo está vazio ou contém a porta padrão do outro protocolo. Deixe **Ignorar erros de certificado** desligado em alvos públicos; ligue apenas em ambientes de teste com certificado próprio.

Para **ajustar o ritmo**, pense em duas travas somadas. O **delay** garante uma pausa mínima após cada envio; use valores maiores (250 a 1000 ms) em alvos sensíveis. As **requisições por segundo** limitam o pico: com `5 REQ/S`, o Intruso espaça os envios para no máximo cinco por segundo. Com `0` (livre), não há teto de taxa e o único freio é o delay mais o tempo natural de resposta.

> [!DICA]
> Quando os dois estão ativos, vale o intervalo maior. `DELAY 500 MS` com `5 REQ/S` resulta em um envio a cada 500 ms, porque 500 ms é maior que os 200 ms exigidos por 5 req/s.

### Origem dos payloads: wordlist e gerador dinâmico

Na aba PAYLOADS, escolha **WORDLIST** para usar uma lista pronta ou **GERADOR DINÂMICO** para criar uma sequência. Com WORDLIST selecionada, toque em **WORDLIST** para abrir o seletor **WORDLIST DO INTRUSO**: as listas internas aparecem primeiro e as suas, criadas nas configurações, logo abaixo. O seletor atualiza as listas sempre que é aberto.

O **gerador dinâmico** monta números por um intervalo. Os campos são:

| Campo | Valores | Padrão | O que faz |
| --- | --- | --- | --- |
| Início | inteiro | 1 | Primeiro número da sequência |
| Fim | inteiro maior ou igual ao início | 25 | Último número (inclusive) |
| Passo | inteiro maior que 0 | 1 | Incremento entre um número e o próximo |
| Padding | inteiro | 0 | Completa com zeros à esquerda até esse tamanho (0 desliga) |
| Prefixo | texto | vazio | Texto fixo antes do número |
| Sufixo | texto | vazio | Texto fixo depois do número |

A linha **Estimativa atual** mostra quantos payloads a configuração vai gerar. O total é `((fim - início) / passo) + 1`. Com Início `1`, Fim `5`, Passo `1` e Padding `3`, a sequência é `001, 002, 003, 004, 005`; com Prefixo `user-`, vira `user-001`… `user-005`.

### Modos de distribuição e combinação

Com duas ou mais posições marcadas, o modo decide como as listas se cruzam. O total estimado aparece no tile de Combinações.

| Modo | O que faz | Total estimado |
| --- | --- | --- |
| Por marca | Uma lista, uma marca por vez (as demais ficam no valor original) | Soma dos tamanhos |
| Todas as marcas | O mesmo item em todas as marcas ao mesmo tempo | Tamanho da primeira lista |
| Alinhadas | Uma lista por marca, pelo mesmo índice | Menor tamanho entre as listas |
| Combinações | Produto cartesiano de todas as listas | Produto dos tamanhos |

**Todas as marcas** é o padrão. **Combinações** tem um teto de **10.000** combinações; acima disso o ataque é bloqueado para evitar execuções enormes. Nos modos **Alinhadas** e **Combinações** com duas ou mais marcas, aparecem os **chips de origem por marca**, que permitem usar uma lista diferente em cada posição; sem override, cada marca usa a origem global.

### Processadores de payload e a cadeia de transformação

Na seção **PROCESSADORES**, toque no botão de adicionar e escolha um passo. Cada chip pode ser reordenado (subir/descer) ou removido; a cadeia é aplicada **na ordem**.

| Processador | Opções | O que faz |
| --- | --- | --- |
| URL | — | Codifica o payload em percent-encoding |
| BASE64 | — | Codifica o payload em Base64 |
| JSON | — | Escapa o payload como string JSON |
| HASH | MD5, SHA-1, SHA-256, SHA-512 | Substitui o payload pelo seu hash |
| AFIXOS | prefixo, sufixo | Adiciona texto antes e/ou depois do payload |
| CAIXA | MAIÚSCULAS, MINÚSCULAS, INVERTER | Muda a caixa das letras |
| UNICODE | — | Escapa caracteres fora de ASCII como `\uXXXX` |

> [!DICA]
> A ordem importa. `AFIXOS` depois de `BASE64` adiciona o texto ao valor já codificado; antes, codifica o texto já com os afixos. Monte a cadeia pensando no formato que o alvo espera.

## Botões e ações

| Botão | Onde | O que faz |
| --- | --- | --- |
| AUTODETECTAR | Aba REQUEST | Detecta e marca campos de query, formulário e JSON |
| MARCAR SELEÇÃO | Aba REQUEST | Marca como posição o trecho selecionado no editor |
| LIMPAR | Aba REQUEST | Remove todas as marcações da request |
| WORDLIST / GERADOR DINÂMICO | Aba PAYLOADS | Alterna a origem dos payloads |
| WORDLIST (seletor) | Aba PAYLOADS | Abre a lista de wordlists internas e do usuário |
| Adicionar processador | Aba PAYLOADS | Acrescenta um passo de transformação à cadeia |
| VER FLUXO | Preparação | Abre a página de resultados |
| INICIAR INTRUSÃO | Preparação | Envia a sonda e dispara o ataque |
| PAUSAR / RETOMAR | Durante a execução | Pausa e retoma sem perder o progresso |
| PARAR INTRUSÃO | Durante a execução | Encerra a sessão em andamento |
| FILTROS | Fluxo | Abre o painel de recorte e filtro |
| LIMPAR (filtros) | Fluxo | Remove todos os filtros ativos |
| Toque longo no resultado | Fluxo | Abre o menu de cópia e de envio ao Repetir |

O menu do resultado (toque longo) oferece: **Enviar para o Repetir**, **Copiar URL**, **Copiar request**, **Copiar headers**, **Copiar body**, **Copiar response**, **Copiar payload** e **Copiar cURL**.

## Passo a passo

### 1. Enviar uma request e marcar automaticamente

1. No [Interceptador](https://netcattest.com/catsuite/docs/modulos/interceptador) ou no [Repetir](https://netcattest.com/catsuite/docs/modulos/repetir), use **Enviar para o Intruso**.
2. O Intruso abre com a request já colada e tenta marcar os campos. Confira os chips `P1`, `P2`… em MARCAÇÕES ATUAIS.
3. Se algo ficou de fora, selecione o trecho no editor e toque em **MARCAR SELEÇÃO**. Para recomeçar, toque em **LIMPAR** e depois **AUTODETECTAR**.

### 2. Ataque com wordlist em uma posição

1. Na aba **ALVO**, confirme host, protocolo e porta.
2. Na aba **REQUEST**, marque a posição (uma só marca).
3. Na aba **PAYLOADS**, mantenha **WORDLIST**, toque no seletor e escolha a lista.
4. Ajuste o ritmo na aba ALVO (por exemplo `DELAY 250 MS` e `5 REQ/S`).
5. Toque em **INICIAR INTRUSÃO** e acompanhe o **LOG DA INTRUSÃO** na página de fluxo.

### 3. Gerador dinâmico com processadores

1. Marque a posição que recebe o número (por exemplo `id=` no corpo ou na query).
2. Na aba PAYLOADS, escolha **GERADOR DINÂMICO** e preencha Início, Fim, Passo e Padding.
3. Confira a **Estimativa atual**.
4. Em **PROCESSADORES**, adicione os passos necessários (por exemplo `AFIXOS` e depois `BASE64`).
5. Inicie o ataque.

### 4. Duas posições com modos Alinhadas ou Combinações

1. Marque **duas** posições (por exemplo usuário e senha).
2. Na aba PAYLOADS, escolha o modo: **Alinhadas** para testar pares por índice, **Combinações** para cruzar tudo.
3. Use os **chips de origem por marca** para dar uma lista a cada posição.
4. Verifique a estimativa (lembre do teto de 10.000 em Combinações) e inicie.

### 5. Recortar e filtrar os resultados

1. Na página de fluxo, toque em **FILTROS**.
2. Em **RECORTE**, ative **DIFERENTE** para ver só o que mudou em relação à sonda, ou **TAMANHO** e informe o `|delta| mín.`.
3. Para texto, ative **GREP** (manter o que casa) ou **EXTRAIR** (puxar um grupo) e digite a regex.
4. Em **MÉTODO E STATUS**, selecione códigos como `200` ou classes como cliente/servidor.
5. Toque em **APLICAR**; o botão mostra quantos resultados sobram. Use **LIMPAR** para voltar à lista completa.

## Exemplos

Request-base antes de marcar, com um campo de ID na query:

```http
GET /api/pedidos?id=1024 HTTP/1.1
Host: alvo.exemplo
Accept: application/json
```

Depois do **AUTODETECTAR**, o valor de `id` é envolvido pelo par de marcadores (a posição aparece como `P1`):

```http
GET /api/pedidos?id=§1024§ HTTP/1.1
Host: alvo.exemplo
Accept: application/json
```

Sequência do gerador dinâmico com Início 1, Fim 5, Passo 1, Padding 3 e Prefixo `user-`:

```text
user-001
user-002
user-003
user-004
user-005
```

Request efetivamente enviada em uma das execuções, já com o payload no lugar da marca:

```http
GET /api/pedidos?id=1031 HTTP/1.1
Host: alvo.exemplo
Accept: application/json
```

## Problemas comuns e perguntas frequentes

**O ataque não inicia e volto para a aba PAYLOADS.** Não há payloads válidos: escolha uma wordlist com linhas ou verifique o gerador (Fim deve ser maior ou igual ao Início). Linhas em branco são ignoradas.

**Digitei o marcador no editor e não funcionou.** No Intruso o marcador não é digitado. Selecione o trecho e use **MARCAR SELEÇÃO**, ou **AUTODETECTAR**. O token literal `$CAT$` pertence ao [Descobridor](https://netcattest.com/catsuite/docs/modulos/descobridor).

**O Combinações ficou bloqueado.** O produto das listas passou de 10.000. Reduza as listas, troque para **Alinhadas** ou use **Por marca**.

**Todos os resultados somem ao filtrar.** Algum filtro está exigente demais (regex que não casa, delta alto, status restrito). Toque em **LIMPAR** no painel de filtros e refine aos poucos.

**Recebo erros de certificado.** Em ambiente de teste com certificado próprio, ligue **Ignorar erros de certificado**. Em produção, mantenha o TLS estrito e investigue o certificado.

**Fechei o app no meio do ataque.** A sessão é salva em disco: ao reabrir o Intruso, request, marcações, payloads e resultados voltam, e você pode **RETOMAR**.

> [!IMPORTANTE]
> Comece sempre com uma lista pequena e ritmo baixo para validar as marcações e a resposta da sonda. Só então aumente o volume. Isso evita disparar milhares de requests por um erro de marcação.

## Boas práticas e segurança

> [!PERIGO]
> Automação em volume pode indisponibilizar um serviço. Dispare o Intruso apenas contra alvos que você está autorizado a testar e combine o ritmo com o responsável pelo sistema.

- Prefira o menor volume que responda à sua pergunta; não teste o intervalo inteiro quando uma amostra basta.
- Use delay e teto de requisições por segundo em alvos de terceiros.
- Compare sempre com a **sonda**: um delta de tamanho ou de status fora do padrão é mais informativo que a lista crua.
- Encaminhe os resultados interessantes para o [Repetir](https://netcattest.com/catsuite/docs/modulos/repetir) e aprofunde um a um.

## Continue

- [Wordlists e payloads](https://netcattest.com/catsuite/docs/modulos/wordlists)
- [Descobridor](https://netcattest.com/catsuite/docs/modulos/descobridor)
- [Repetir](https://netcattest.com/catsuite/docs/modulos/repetir)
- [Interceptador](https://netcattest.com/catsuite/docs/modulos/interceptador)
- [Segurança e uso responsável](https://netcattest.com/catsuite/docs/seguranca)