AfterLife — Laboratório de detecção de persistência de revogação: quando a redefinição de senha é bem-sucedida, mas o atacante nunca vai embora. Reproduz o bug de revogação condicional do Strapi CVE-2026-22706, sua correção, um pacote de detecção com três regras e a regra ingênua que não o detecta. | Kitploit

Sem erro. Sem anomalia. Sem autenticação falhada para contar. A credencial de acesso do atacante tem *três segundos de vida* e foi emitida pelo servidor, a pedido, após o reset.

Eis a vulnerabilidade completa:```python
def _revoke_for_security_change(self, user, kind, device_id):
    if device_id:
        revoke_credentials(user, device_id=device_id)   # ← the finding

Não é uma regra estúpida. É barata, precisa de um campo, lê-se como a definição
do problema, e está **correta quanto ao caso simples** — um atacante que use um
token de *acesso* roubado após o reset é apanhado.
`test_the_naive_rule_catches_the_simple_case` afirma que funciona.

Ambas as regras fazem a mesma pergunta sobre a mesma credencial. Leem campos
diferentes para responder, e os dois campos discordam:

![Duas linhas, uma por campo. credential.issued_at lê 10:00:03, três segundos após a alteração, e conclui que a credencial parece limpa. lineage.root_issued_at lê 09:00:00, uma hora antes da alteração, e alerta.](https://raw.githubusercontent.com/het-p301204/afterlife/main/docs/figures/two-fields.svg)

**Três segundos depois, ou uma hora antes — a mesma credencial, no mesmo
instante.** A regra ingénua pergunta a um campo que o atacante controla, e um
`POST /refresh` reinicia-o.

Executa-a sobre o registo de pedidos, que é onde esta consulta é realmente escrita,
porque os registos de pedidos são o que tens:```text
NAIVE DETECTOR (NAIVE-001), over the request log

  Result: NO ALERT

  Six requests were served to the attacker after the reset. Every one of them
  carried at-004, minted at 10:00:03 -- three seconds *after* the password
  change. By its own timestamp it is the newest credential on the account.

Essa é a diferença que importa às 3 da manhã. A regra ingênua captura o único
instante em que a cadeia cruza a fronteira, e então perde o rastro pelos 29 dias
restantes — e a credencial que ela nomeia *já foi rotacionada e revogada
pelo servidor*. Revogá-la não resolve nada. `lin-001` é o objeto que você
precisa eliminar.

**E a regra ingênua não foi privada de telemetria.** Ela usa o mesmo fluxo de
eventos, o mesmo índice de linhagem, a mesma tolerância, a mesma deduplicação e
o mesmo estado limitado. Ela sobrescreve um método:```python
class Correlator:                                  # AFTERLIFE-001
    def _age_reference(self, facts):
        return facts.root_issued_at

class NaiveCorrelator(Correlator):                 # NAIVE-001
    def _age_reference(self, facts):
        return facts.issued_at

	regra	severidade	responde	dispara
AFTERLIFE-002	Reutilização de credencial de refresh	CRITICAL / MEDIUM	foi roubada?	na reutilização
AFTERLIFE-003	Revogação incompleta em uma mudança de segurança	HIGH / LOW	a contenção foi executada?	na mudança — nenhum atacante necessário
AFTERLIFE-001	Uso de linhagem de credencial pós-revogação	HIGH	a linhagem obsoleta foi usada?	na primeira aceitação
RULE PACK

**Essa ordenação é a coisa mais útil neste repositório.** AFTERLIFE-003
dispara no instante em que a alteração é aplicada, três segundos antes de o atacante tocar
em qualquer coisa, porque a evidência de que necessita já está completa: o log diz quais
linhagens estavam ativas à entrada, e não diz que foram revogadas.

Não precisa de vítima nem de exploração. Reportará o defeito na primeira
redefinição de palavra-passe que qualquer utilizador efetue — o que o torna o único que se executa em staging,
onde não há atacante para esperar. AFTERLIFE-001 diz-lhe que uma violação está
em curso; AFTERLIFE-003 diz-lhe que o seu controlo de contenção está avariado.

![Dois cartões de alerta. AFTERLIFE-003 às 10:00:00 reporta veredicto no_containment, watermark não registado, âmbito nenhum, e lin-001 sobrevivente. AFTERLIFE-001 às 10:00:03 reporta credencial rt-002 com um root emitido uma hora antes da alteração.](https://raw.githubusercontent.com/het-p301204/afterlife/main/docs/figures/findings-vulnerable.svg)

`application recorded watermark: no` é o campo que aponta um socorrista de incidentes
para o *defeito* em vez de para o sintoma.

### A watermark que as regras usam não é a que a aplicação reporta

O evento de alteração de credencial transporta um campo `revocation_watermark` — o
valor `credentials_valid_after` que a aplicação escreveu. **Na implementação
vulnerável é `null`, porque a aplicação nunca escreveu nenhum.** Esse é
o bug.

Portanto, uma regra baseada nesse campo estaria cega precisamente ao caso que existe para
apanhar. As regras ancoram no `timestamp` do próprio evento, que é verdadeiro quer a
aplicação tenha feito o seu trabalho quer não, e reportam o campo em falta como evidência.

### Propriedades```text
  deduplication        6 accepted requests on the stale lineage -> 1 alert
  event order          shuffled stream -> same alert  (1 alert)
  duplicate telemetry  log replayed twice -> 1 alert  (24 duplicate events discarded)
  false positives      the fixed implementation's log -> 0 alerts
  bounded state        caps at 256 activity/user, 2000 users, 20000 credentials

grava **[`docs/console-preview.html`](https://github.com/het-p301204/afterlife/blob/main/docs/console-preview.html)** — um
arquivo autocontido de 74 KiB com ambas as execuções incorporadas. Sem servidor, sem rede, sem
fontes para buscar; abra-o a partir do sistema de arquivos. Ou execute a versão ao vivo:```bash
python -m console

O aplicativo é executado **in-process** sob a demo, o console e os testes. Sem
portas, sem servidor de desenvolvimento, sem Docker. O relógio é fixado, então cada execução é
determinística e a telemetria, o console, as figuras e os relatórios commitados são todos
byte-idênticos entre execuções — o que o CI verifica com `git diff --exit-code`.

### Aplicação no lado do servidor

Uma credencial é uma **linha**, não uma string. O JWT que o cliente possui carrega `cid` —
uma chave de consulta — e a linha decide se a credencial está ativa.

A expiração é verificada em relação ao `expires_at` da linha, não em relação à claim `exp`
que o portador apresentou. Ambas as claims temporais são entregues ao PyJWT com `verify=False`,
o que aqui significa *"o servidor verifica isso por conta própria"*, e [`app/auth.py`](https://github.com/het-p301204/afterlife/blob/main/app/auth.py)
faz isso, em cada requisição. O cliente nunca tem voto sobre se sua própria
credencial ainda é válida.

---

## Linha do tempo do ataque```mermaid
flowchart TD
    A["Account compromised<br/><i>phishing · XSS · stolen backup</i>"] --> B["Attacker holds refresh credential rt-001<br/>lineage lin-001, root sess-001 @ 09:00"]
    B --> C["Legitimate password change @ 10:00<br/>HTTP 200 · password hash updated"]
    C --> D{"device_id supplied?"}
    D -->|"yes"| E["revoke_credentials(user, device_id)<br/>rt-001 revoked"]
    D -->|"no — the exploit"| F["nothing revoked<br/>no watermark written"]
    E --> G["Attacker refresh → 401<br/><b>contained</b>"]
    F --> AF3["<b>AFTERLIFE-003 · HIGH</b> @ 10:00:00<br/>containment did not run<br/><i>no attacker action required</i>"]
    F --> H["POST /refresh rt-002 → 200<br/>mints at-004 @ 10:00:03"]
    H --> I["GET /me at-004 → 200<br/>well-formed · correctly signed · <b>no anomaly</b>"]
    I --> J["at-004.issued_at > watermark<br/>NAIVE-001: no alert"]
    I --> K["lineage lin-001 root @ 09:00 < watermark<br/><b>AFTERLIFE-001 · HIGH</b>"]
    F --> L["attacker holds and never spends<br/>AFTERLIFE-001 silent — correctly<br/><b>state audit: dormant survivor</b>"]

    style F fill:#7f1d1d,color:#fff
    style H fill:#7f1d1d,color:#fff
    style I fill:#7f1d1d,color:#fff
    style J fill:#78350f,color:#fff
    style K fill:#14532d,color:#fff
    style AF3 fill:#14532d,color:#fff
    style L fill:#1e3a5f,color:#fff
    style E fill:#14532d,color:#fff
    style G fill:#14532d,color:#fff

`at-004` tem três segundos de idade. A sua ascendência tem uma hora de idade. Ambos os factos são verdadeiros, e apenas um deles é visível num registo de pedidos.

Dois invariantes mantêm isto coeso, e ambos são testados:

1. **Apenas a autenticação cria uma linhagem.** `Store.open_session` é o único
   local onde um `lineage_id` é gerado, e torna a sessão o seu próprio
   `root_credential_id`.
2. **A criação de tokens copia a raiz para baixo.** `TokenService.mint` lê os campos da linhagem
   do progenitor em vez de os recalcular, pelo que uma credencial não pode adquirir uma
   ascendência mais recente do que o início de sessão de que descende.

Um token apresentado pelo titular deliberadamente **não** transporta a sua raiz de linhagem. Se o
fizesse, o titular poderia mentir sobre ela.

---

## A auditoria de estado

AFTERLIFE-001 dispara quando uma linhagem obsoleta é *utilizada*. Esse é o gatilho correto para
uma regra de deteção, e deixa um buraco: **uma linhagem obsoleta que ninguém tocou é
invisível para ela.** Um atacante que rouba uma credencial, observa a reposição falhar,
e depois espera, não produz atividade para correlacionar.

Por isso o laboratório também faz a pergunta que uma regra não consegue: não *o que aconteceu*, mas *o que
ainda está vivo*.```text
  scenario: dormant-survivor   (the attacker holds the credential and never spends it)

  AFTERLIFE-001   silent   — correct; nothing was accepted
  AFTERLIFE-003   HIGH     — the change revoked nothing
  state audit     1 stale lineage, 1 dormant

| `-s` | `--server` | `SERVER` | `http://localhost:8080` | URL do servidor |
| `-t` | `--token` | `TOKEN` | `None` | Token de autenticação |
| `-u` | `--username` | `USERNAME` | `None` | Nome de usuário para autenticação |
| `-p` | `--password` | `PASSWORD` | `None` | Senha para autenticação |
| `-k` | `--insecure` | `False` | `False` | Ignorar verificação de certificado SSL |
| `-v` | `--verbose` | `False` | `False` | Ativar saída detalhada |
| `-d` | `--debug` | `False` | `False` | Ativar saída de depuração |
| `-q` | `--quiet` | `False` | `False` | Suprimir saída |
| `-o` | `--output` | `OUTPUT` | `None` | Arquivo de saída |
| `-f` | `--format` | `FORMAT` | `json` | Formato de saída (json, yaml, table) |
| `-c` | `--config` | `CONFIG` | `None` | Arquivo de configuração |
| `-h` | `--help` | `False` | `False` | Mostrar mensagem de ajuda e sair |
| `-V` | `--version` | `False` | `False` | Mostrar versão e sair |

### Exemplos

```bash
# Obter informações do servidor
$ ./tool -s http://localhost:8080 -t TOKEN

# Obter informações do servidor com saída detalhada
$ ./tool -s http://localhost:8080 -t TOKEN -v

# Obter informações do servidor com saída de depuração
$ ./tool -s http://localhost:8080 -t TOKEN -d

# Obter informações do servidor com saída silenciosa
$ ./tool -s http://localhost:8080 -t TOKEN -q

# Obter informações do servidor com arquivo de saída
$ ./tool -s http://localhost:8080 -t TOKEN -o output.json

# Obter informações do servidor com formato de saída
$ ./tool -s http://localhost:8080 -t TOKEN -f yaml

# Obter informações do servidor com arquivo de configuração
$ ./tool -s http://localhost:8080 -t TOKEN -c config.yaml

# Obter informações do servidor com autenticação
$ ./tool -s http://localhost:8080 -u USERNAME -p PASSWORD

# Obter informações do servidor com autenticação e ignorar verificação de certificado SSL
$ ./tool -s http://localhost:8080 -u USERNAME -p PASSWORD -k

# Obter informações do servidor com autenticação e saída detalhada
$ ./tool -s http://localhost:8080 -u USERNAME -p PASSWORD -v

# Obter informações do servidor com autenticação e saída de depuração
$ ./tool -s http://localhost:8080 -u USERNAME -p PASSWORD -d

# Obter informações do servidor com autenticação e saída silenciosa
$ ./tool -s http://localhost:8080 -u USERNAME -p PASSWORD -q

# Obter informações do servidor com autenticação e arquivo de saída
$ ./tool -s http://localhost:8080 -u USERNAME -p PASSWORD -o output.json

# Obter informações do servidor com autenticação e formato de saída
$ ./tool -s http://localhost:8080 -u USERNAME -p PASSWORD -f yaml

# Obter informações do servidor com autenticação e arquivo de configuração
$ ./tool -s http://localhost:8080 -u USERNAME -p PASSWORD -c config.yaml
``````text
VULNERABLE
  server state   1 lineage(s) outlived the change   (0 dormant)
  telemetry      1 lineage(s)   -- the same question, asked of the log instead of the database
    lin-001 root 2026-09-11T09:00:00.000Z  7 credentials  in use

FIXED
  server state   clean
  telemetry      clean

cenário	modo	eventos	pior	regras disparadas	stale
`legitimate-only`	vulnerable	19	LOW	`AFTERLIFE-003`	0
`legitimate-only`	fixed	19	–	none	0
`stolen-refresh`	vulnerable	22	HIGH	`AFTERLIFE-001`, `AFTERLIFE-003`	1
`stolen-refresh`	fixed	23	–	none	0
`stolen-refresh-with-device-id`	vulnerable	19	LOW	`AFTERLIFE-003`	0
`stolen-refresh-with-device-id`	fixed	19	–	none	0
`multi-device`	vulnerable	29	HIGH	`AFTERLIFE-001`, `AFTERLIFE-003`	2
`multi-device`	fixed	29	–	none	0
`refresh-reuse`	vulnerable	11	MEDIUM	`AFTERLIFE-002`	0
`refresh-reuse`	fixed	15	MEDIUM	`AFTERLIFE-002`	0

caso	resultado	por quê
Mudança de senha, depois a sessão substituta é usada	sem alerta	a raiz da nova linhagem está na marca d'água ou depois dela
Redefinição seguida de navegação imediata (`/me`, `/profile`, `/settings`)	sem alerta	uma linhagem nova, uma raiz nova
Telefone, laptop e tablet, todos corretamente rotacionados	sem alerta	cada login é sua própria linhagem
Um dispositivo que fez login após a mudança, navegando junto com o atacante	sem alerta	raiz nova — e a linhagem obsoleta ainda alerta, sozinha
Uma credencial obsoleta que foi rejeitada	sem alerta	`result: failure` é excluído; é evidência para a defesa
Desvio de relógio de até 2s entre componentes	sem alerta	a tolerância documentada
Uma mudança de senha malsucedida	sem alerta	não é uma âncora
Atividade antes da mudança	sem alerta	verificação de ordenação temporal
Uma credencial rotacionada (`reason: rotated`)	não contada como morte	uma credencial gasta, não uma linhagem morta
Uma sessão de 40 dias cujas credenciais expiraram	não é uma sobrevivente	expiração rastreada por linhagem
Uma primeira mudança de senha em uma conta nova	sem alerta	nada estava ativo antes
Rotação de refresh token de uma linhagem obsoleta	ALERTA	timestamp novo, ancestralidade obsoleta — este é o achado

Nenhum dos dois depende de `device_id`. Ele é registrado como contexto e não tem influência no
raio de impacto.

**A marca d'água é a garantia arquitetural.** Um timestamp por usuário,
`credentials_valid_after`, comparado em cada requisição tanto contra a
própria emissão da credencial *quanto* contra sua raiz de linhagem:```python
watermark = user.credentials_valid_after
if credential.issued_at      < watermark:  reject  # the obvious case
if credential.root_issued_at < watermark:  reject  # the refresh chain

alteração	porque é que as credenciais se tornam não confiáveis
alteração / reposição de palavra-passe	o segredo com que a sessão foi estabelecida desapareceu
inscrição ou alteração de MFA	os fatores com que a sessão foi estabelecida não são os fatores da conta
alteração de função / escalada de privilégios	a credencial foi emitida sob uma autorização diferente
recuperação de conta	por construção, a conta pode ter estado nas mãos de outra pessoa há um momento
início de sessão	não revoga as outras — uma nova linhagem, não uma afirmação de que as antigas não são confiáveis

	mecanismo	ganha	custa
A	marca de água de revogação por utilizador	uma escrita revoga tudo, incluindo credenciais que o servidor se esqueceu; armazenamento e verificação O(1)	estado do lado do servidor no caminho de leitura; a semântica de timestamp tem de estar exatamente certa; não diz nada sobre credenciais emitidas após a marca de água
B	acesso de curta duração + refresh revogável	limita os danos do token de acesso sem estado no caminho de leitura	um token de acesso roubado é válido até expirar; o lado do refresh ainda precisa de estado — este é o padrão dentro do qual o CVE vive
C	denylist explícita	precisa; legível para um responsável de incidentes; produz a telemetria que prova a contenção	o estado cresce e precisa de limpeza; só revoga o que te lembraste de enumerar — que é a consulta que o bug errou
D	JWT totalmente sem estado	nenhum estado no caminho de leitura	não há revogação. O TTL e a rotação de chaves são as únicas alavancas

| arquivo | o que ele fixa |
|---|---|
| [`test_fixed_mode.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_fixed_mode.py) | **a suíte de regressão que nunca pode ficar vermelha** — nenhuma credencial emitida antes de um evento de revogação é aceita depois dele, incluindo uma descendente de uma linhagem obsoleta |
| [`test_vulnerable_mode.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_vulnerable_mode.py) | a vulnerabilidade **existe**, é determinística, dura 30 dias e é causada pelo condicional — com o controle `device_id` provando que o caminho de revogação é opcional em vez de morto |
| [`test_lineage.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_lineage.py) | uma cadeia de refresh mantém uma linhagem e uma raiz; apenas o login cria uma linhagem |
| [`test_detector_afterlife001.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_detector_afterlife001.py) | 7 casos de detecção, 9 casos de falso positivo, 2 pontos cegos, todas as 24 ordenações de eventos, estado limitado, entrada malformada |
| [`test_detector_rulepack.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_detector_rulepack.py) | AFTERLIFE-002 e AFTERLIFE-003 — cada veredito, a janela de carência, rotação-não-é-morte, exclusão de expiração e a ordenação do motor |
| [`test_naive_detector.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_naive_detector.py) | NAIVE-001 continua falhando **da maneira específica que este README afirma** — incluindo que ele tinha os dados de que precisava |
| [`test_audit_and_console.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_audit_and_console.py) | o sobrevivente dormente que nenhuma regra consegue ver; ambas as fontes de auditoria concordando; o console não computando nenhum veredito próprio; a pré-visualização offline não buscando nada; cada número neste README dentro dos limites, sem folha de estilo e byte-estável |
| [`test_scenarios.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_scenarios.py) | as linhas da matriz que carregam um argumento |
| [`test_privilege_changes.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_privilege_changes.py) | MFA, mudança de função e recuperação de conta, ambos os modos |
| [`test_telemetry.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_telemetry.py) | o contrato de redação e um grep do log pelas strings bearer literais emitidas |
| [`test_app.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_app.py) | assinaturas forjadas, tipos de credencial errados, expiração a partir do estado do servidor |
| [`test_infrastructure.py`](https://github.com/het-p301204/afterlife/blob/main/tests/test_infrastructure.py) | configuração, relógio, linhas parciais do tailer, ambas as CLIs, cada comando de demonstração |

O teste mais forte da suíte é
`test_no_bearer_string_or_password_ever_reaches_the_log`: ele executa todo o ataque
e então procura no arquivo de log as credenciais reais que a aplicação entregou,
mais ambas as senhas, mais a chave de assinatura. Não por nomes de campos — pelos
valores.

---

## Pontos cegos

Declarados abertamente, porque escondê-los tornaria o laboratório desonesto. Cada um tem um teste.

> **Se a aplicação não emite eventos de mudança de credencial, o pacote não consegue
> correlacionar de forma confiável a atividade pós-reset.** Não há âncora, então não há
> nada para a atividade estar "depois" — e isso silencia o AFTERLIFE-003 primeiro, que é a
> regra que teria lhe dito que o controle estava quebrado.
>
> **Se a aplicação não retém metadados de emissão/linhagem, o detector
> não consegue determinar se um token de acesso novo descendeu de uma credencial
> mais antiga.** Uma credencial emitida há três segundos é indistinguível de uma
> credencial emitida há três segundos por uma cadeia de um mês.

Estas **não são preferências opcionais de logging. São requisitos de detecção de
segurança.** Abandonar `auth.token.issued` para reduzir o volume de logs não torna o
logging mais barato; desliga uma detecção.

Atividade irresolvível é **contada**, não silenciosamente descartada —
`stats()["activity_with_unresolved_lineage"]` é diferente de zero sempre que o detector
foi questionado sobre credenciais que a telemetria nunca descreveu. Uma regra que fica
quieta porque nada está errado e uma regra que fica quieta porque está cega parecem
idênticas vistas de fora, e esse número é a diferença.

Também verdadeiro, e também documentado:

* **O detector não pode recusar uma requisição.** Ele acompanha um log. Ele lhe diz
  que a contenção falhou; ele não contém.
* **A auditoria é uma varredura, não uma detecção.** Ela fecha a lacuna do
  sobrevivente dormente, mas roda quando alguém a executa. Ela não pode paginar.
* **A correção não ajuda com credenciais roubadas *depois* do reset.** A contenção
  é um ponto no tempo, não uma propriedade.
* **AFTERLIFE-003 verifica a contenção observada, não a completude arquitetural.**
  Uma revogação com escopo de dispositivo que por acaso cobre tudo recebe a
  descoberta LOW, não a HIGH. O bug ainda está lá; ele não mordeu naquela
  conta. Um teste pode perguntar "e quanto a dois dispositivos?"; um log só pode
  relatar o que de fato aconteceu.
* **Outras persistências sobrevivem inteiramente a uma mudança de senha** — concessões OAuth, chaves
  de API, regras de encaminhamento de e-mail, contatos de recuperação.

Discussão completa: **[docs/limitations.md](https://github.com/het-p301204/afterlife/blob/main/docs/limitations.md)**.

---

## Executando o laboratório```bash
python -m venv .venv
source .venv/bin/activate          # Windows: .venv\Scripts\activate

pip install -r requirements.txt -r requirements-dev.txt

pytest -q

| `--no-color` | Desativa a saída colorida |
| `--verbose` | Ativa o registro detalhado |
| `--quiet` | Suprime toda a saída, exceto erros |
| `--output <file>` | Grava a saída em um arquivo |
| `--format <type>` | Especifica o formato de saída (json, yaml, table) |
| `--config <file>` | Caminho para o arquivo de configuração |
| `--timeout <seconds>` | Define o tempo limite da operação |
| `--retry <count>` | Número de tentativas em caso de falha |
| `--proxy <url>` | Usa o proxy especificado para conexões |
| `--insecure` | Ignora a verificação de certificado TLS |
| `--threads <num>` | Número de threads concorrentes |
| `--rate-limit <n>` | Limita as requisições a n por segundo |
| `--user-agent <str>` | Define um User-Agent personalizado |
| `--header <header>` | Adiciona um cabeçalho HTTP personalizado |
| `--cookie <cookie>` | Envia cookies com as requisições |
| `--data <data>` | Envia dados no corpo da requisição |
| `--method <method>` | Especifica o método HTTP |
| `--follow-redirects` | Segue redirecionamentos HTTP |
| `--max-redirects <n>` | Número máximo de redirecionamentos a seguir |
| `--resolve <host:ip>` | Resolve um hostname para um IP específico |
| `--interface <name>` | Vincula a uma interface de rede específica |
| `--source-ip <ip>` | Define o endereço IP de origem |
| `--dns-server <ip>` | Usa um servidor DNS personalizado |
| `--no-dns` | Desativa a resolução DNS |
| `--ipv4` | Usa apenas IPv4 |
| `--ipv6` | Usa apenas IPv6 |
| `--random-agent` | Usa um User-Agent aleatório |
| `--delay <ms>` | Adiciona um atraso entre as requisições |
| `--jitter <ms>` | Adiciona variação aleatória ao atraso |
| `--max-size <bytes>` | Tamanho máximo da resposta a processar |
| `--min-size <bytes>` | Tamanho mínimo da resposta a processar |
| `--match <regex>` | Filtra a saída por uma expressão regular |
| `--filter <regex>` | Exclui da saída o que corresponder a uma expressão regular |
| `--exclude <pattern>` | Exclui caminhos correspondentes ao padrão |
| `--include <pattern>` | Inclui apenas caminhos correspondentes ao padrão |
| `--extensions <list>` | Extensões de arquivo a testar |
| `--wordlist <file>` | Arquivo de wordlist a usar |
| `--rules <file>` | Arquivo de regras a aplicar |
| `--templates <dir>` | Diretório de templates a usar |
| `--severity <level>` | Filtra por nível de severidade |
| `--tags <tags>` | Filtra por tags |
| `--exclude-tags <tags>` | Exclui por tags |
| `--update` | Atualiza templates e assinaturas |
| `--version` | Exibe a versão e sai |
| `--help` | Exibe a mensagem de ajuda e sai |```bash
python scripts/lab.py detect

## 4.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.2.```bash
python scripts/lab.py audit

Todo o resto — a CLI do detector, a matriz, o relatório, as figuras, os servidores

Reproduza as evidências commitadas através do pacote. Nenhuma execução da aplicação é necessária — o detector é estritamente a jusante, e esta é a prova:```bash python -m detector --once --timeline --events evidence/vulnerable-persistence.jsonl

Uma regra de cada vez, ou a ingênua, ou a varredura de estado:```bash
python -m detector --once --rule AFTERLIFE-003 --events evidence/vulnerable-persistence.jsonl

I'm ready to translate the Kitploit tool content from English to Portuguese. Please provide chunk 57 of 79.```bash python -m detector --once --naive --events evidence/vulnerable-persistence.jsonl

## 🎯 Objetivos de Aprendizagem

Após completar este módulo, você será capaz de:

- Entender o que é o Model Context Protocol (MCP) e por que ele importa
- Identificar os três componentes principais da arquitetura MCP
- Reconhecer os três primitivos MCP (Tools, Resources, Prompts)
- Compreender os dois tipos de transporte (stdio e HTTP/SSE)
- Configurar servidores MCP em diferentes clientes
- Aplicar as melhores práticas de segurança MCP
- Construir um servidor MCP básico usando Python ou TypeScript

## 📚 Pré-requisitos

Antes de começar este módulo, você deve ter:

- **Compreensão básica de LLMs**: Familiaridade com como os Modelos de Linguagem Grandes funcionam
- **Experiência com Python ou TypeScript**: Capacidade de ler e escrever código em pelo menos uma dessas linguagens
- **Familiaridade com APIs**: Entendimento de APIs REST e requisições HTTP
- **Conhecimento de linha de comando**: Conforto com operações básicas de terminal
- **Conceitos de segurança**: Compreensão básica de princípios de segurança

## 🗺️ Visão Geral do Módulo

Este módulo está organizado nas seguintes seções:

1. **Introdução ao MCP** - O que é e por que você deveria se importar
2. **Arquitetura MCP** - Entendendo os componentes principais
3. **Primitivos MCP** - Tools, Resources e Prompts
4. **Transportes MCP** - stdio vs HTTP/SSE
5. **Configuração de Clientes MCP** - Configurando diferentes clientes
6. **Segurança MCP** - Melhores práticas e armadilhas comuns
7. **Construindo um Servidor MCP** - Guia de implementação prática
8. **Exercícios** - Prática prática
9. **Recursos Adicionais** - Aprendizado complementar

## 1. Introdução ao MCP

### O que é o Model Context Protocol?

O Model Context Protocol (MCP) é um padrão aberto que permite que aplicações forneçam contexto a Modelos de Linguagem Grandes (LLMs) de uma maneira padronizada. Pense nisso como um **"USB-C para IA"** - uma maneira universal de conectar modelos de IA a fontes de dados e ferramentas externas.

### Por que o MCP Importa

Antes do MCP, integrar LLMs com ferramentas externas exigia:

- **Integrações personalizadas** para cada combinação de modelo e ferramenta
- **Código específico de fornecedor** que não era portável entre diferentes LLMs
- **Sobrecarga de manutenção** ao atualizar integrações
- **Desafios de segurança** ao gerenciar múltiplos pontos de integração

O MCP resolve esses problemas fornecendo:

- **Uma interface padronizada** para integração de ferramentas
- **Portabilidade** entre diferentes clientes e modelos
- **Segurança** através de padrões de design bem definidos
- **Reutilização** de servidores MCP entre múltiplas aplicações

### O Problema que o MCP Resolve

Considere um cenário onde você deseja que seu assistente de IA:

1. Leia arquivos do seu sistema de arquivos local
2. Consulte um banco de dados
3. Faça requisições de API para serviços externos
4. Interaja com seu sistema de controle de versão

Sem o MCP, você precisaria:

- Escrever código de integração personalizado para cada combinação de cliente e ferramenta
- Lidar com autenticação e autorização de forma diferente para cada integração
- Manter múltiplas bases de código à medida que as APIs evoluem
- Reimplementar a mesma funcionalidade para diferentes clientes de IA

Com o MCP, você:

- Constrói um servidor MCP uma vez e o usa em qualquer lugar
- Usa padrões de segurança padronizados
- Mantém uma única base de código
- Compartilha servidores MCP com a comunidade

### Ecossistema MCP

O ecossistema MCP inclui:

- **Servidores MCP**: Fornecem ferramentas, recursos e prompts
- **Clientes MCP**: Aplicações que se conectam a servidores MCP (ex.: Claude Desktop, IDEs)
- **SDKs MCP**: Bibliotecas para construir servidores e clientes MCP
- **Registro MCP**: Um diretório de servidores MCP disponíveis publicamente

### Casos de Uso do Mundo Real

O MCP está sendo usado em vários cenários:

- **Assistentes de código**: Acessando documentação, bases de código e ferramentas de desenvolvimento
- **Análise de dados**: Consultando bancos de dados e executando análises
- **Automação de fluxos de trabalho**: Integrando com ferramentas de negócios e APIs
- **Pesquisa**: Acessando artigos acadêmicos e conjuntos de dados
- **Operações de TI**: Gerenciando infraestrutura e monitoramento

## 2. Arquitetura MCP

### Visão Geral da Arquitetura

O MCP segue uma arquitetura cliente-servidor com três componentes principais:

┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ │ │ │ │ │ │ Aplicação │◄───────►│ Cliente │◄───────►│ Servidor │ │ Hospedeira │ │ MCP │ │ MCP │ │ │ │ │ │ │ └─────────────────┘ └─────────────────┘ └─────────────────┘


### Componentes Principais

#### 1. Aplicação Hospedeira

A aplicação hospedeira é o programa que o usuário está executando. Ela:

- Fornece a interface do usuário
- Gerencia a conversa com o LLM
- Inicia conexões com servidores MCP
- Controla quais servidores MCP estão disponíveis

Exemplos: Claude Desktop, Cursor, VS Code com extensões de IA

#### 2. Cliente MCP

O cliente MCP é um componente dentro da aplicação hospedeira que:

- Mantém conexões com servidores MCP
- Lida com o protocolo de comunicação
- Gerencia o ciclo de vida da conexão
- Encaminha requisições e respostas

#### 3. Servidor MCP

O servidor MCP é um programa que:

- Expõe ferramentas, recursos e prompts
- Lida com requisições de clientes MCP
- Executa operações em nome do LLM
- Retorna resultados ao cliente

### Fluxo de Comunicação

Aqui está como a comunicação flui em uma interação típica do MCP:

1. **Descoberta**: O cliente MCP se conecta ao servidor MCP e descobre capacidades
2. **Requisição**: O LLM decide usar uma ferramenta e o cliente envia uma requisição
3. **Execução**: O servidor MCP executa a operação solicitada
4. **Resposta**: O servidor retorna os resultados ao cliente
5. **Integração**: O cliente fornece os resultados de volta ao LLM

### Detalhes do Protocolo

O MCP usa JSON-RPC 2.0 como seu protocolo de mensagens. Isso significa:

- Todas as mensagens são formatadas como objetos JSON
- As mensagens seguem a especificação JSON-RPC 2.0
- As mensagens podem ser requisições, respostas ou notificações
- O protocolo suporta capacidades de streaming

Exemplo de uma requisição MCP:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "read_file",
    "arguments": {
      "path": "/path/to/file.txt"
    }
  }
}

Exemplo de uma resposta MCP:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Conteúdo do arquivo..."
      }
    ]
  }
}

Ciclo de Vida da Conexão

As conexões MCP seguem um ciclo de vida definido:

Inicialização: O cliente se conecta ao servidor e negocia capacidades
Operação: O cliente e o servidor trocam mensagens
Encerramento: A conexão é fechada de forma limpa

Durante a inicialização, o cliente e o servidor trocam informações sobre:

Versões de protocolo suportadas
Capacidades (quais primitivos são suportados)
Informações do cliente/servidor

3. Primitivos MCP

O MCP define três primitivos principais que os servidores podem expor:

3.1 Tools (Ferramentas)

Tools são funções que o LLM pode chamar para executar ações. Elas são o primitivo mais comumente usado.

Características das Tools:

Orientadas a ações: Executam operações e retornam resultados
Controladas pelo modelo: O LLM decide quando chamá-las
Com efeitos colaterais: Podem modificar estado ou causar efeitos externos
Com parâmetros: Aceitam argumentos de entrada

Exemplo de definição de uma Tool:

{
  "name": "get_weather",
  "description": "Obtém o clima atual para um local",
  "inputSchema": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "Nome da cidade ou coordenadas"
      },
      "units": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "Unidades de temperatura"
      }
    },
    "required": ["location"]
  }
}

Casos de uso comuns para Tools:

Consultar bancos de dados
Fazer requisições de API
Ler ou escrever arquivos
Executar cálculos
Enviar mensagens ou e-mails

3.2 Resources (Recursos)

Resources representam dados que o LLM pode ler. Elas fornecem contexto sem executar ações.

Características dos Resources:

Orientados a dados: Fornecem informações
Controlados pela aplicação: A aplicação hospedeira decide o que incluir
Somente leitura: Não modificam estado
Endereçáveis: Identificados por URIs

Exemplo de definição de um Resource:

{
  "uri": "file:///path/to/document.txt",
  "name": "Documento",
  "description": "Um documento de texto",
  "mimeType": "text/plain"
}

Casos de uso comuns para Resources:

Arquivos e documentos
Registros de banco de dados
Respostas de API
Dados de configuração
Trechos de código

3.3 Prompts (Prompts)

Prompts são templates reutilizáveis que ajudam os usuários a interagir com o LLM.

Características dos Prompts:

Orientados a templates: Fornecem estruturas reutilizáveis
Controlados pelo usuário: Os usuários escolhem quando usá-los
Parametrizados: Aceitam argumentos de entrada
Com foco em fluxo de trabalho: Projetados para tarefas específicas

Exemplo de definição de um Prompt:

{
  "name": "code_review",
  "description": "Revisa código em busca de problemas",
  "arguments": [
    {
      "name": "code",
      "description": "O código a ser revisado",
      "required": true
    },
    {
      "name": "language",
      "description": "A linguagem de programação",
      "required": false
    }
  ]
}

Casos de uso comuns para Prompts:

Templates de revisão de código
Fluxos de trabalho de análise de dados
Geração de documentação
Processos de depuração
Tarefas de pesquisa

Comparando os Primitivos

4. Transportes MCP

O MCP suporta dois mecanismos de transporte para comunicação:

4.1 Transporte stdio

O transporte stdio usa entrada e saída padrão para comunicação. É o transporte mais comum para servidores MCP locais.

Características:

Baseado em processo: O servidor é executado como um subprocesso
Comunicação local: Sem sobrecarga de rede
Simples: Fácil de implementar e depurar
Seguro: Sem exposição de rede por padrão

Como funciona:

A aplicação hospedeira inicia o servidor MCP como um subprocesso
As mensagens são enviadas via stdin do servidor
As respostas são recebidas via stdout do servidor
Erros e logs vão para stderr

Exemplo de configuração:

{
  "mcpServers": {
    "my-server": {
      "command": "python",
      "args": ["-m", "my_mcp_server"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

Melhores práticas para transporte stdio:

Sempre use stderr para logging (nunca stdout)
Lide com o encerramento graciosamente
Valide todas as entradas
Mantenha as respostas concisas

4.2 Transporte HTTP/SSE

O transporte HTTP/SSE usa HTTP com Server-Sent Events para comunicação. É usado para servidores MCP remotos.

Características:

Baseado em rede: O servidor é executado como um serviço web
Comunicação remota: Pode ser acessado pela rede
Escalável: Suporta múltiplos clientes
Requer segurança: Precisa de autenticação e criptografia

Como funciona:

O cliente se conecta ao servidor via HTTP
O cliente envia requisições via POST HTTP
O servidor envia respostas via Server-Sent Events
A conexão é mantida aberta para streaming

Exemplo de configuração:

{
  "mcpServers": {
    "remote-server": {
      "url": "https://api.example.com/mcp",
      "headers": {
        "Authorization": "Bearer your-token"
      }
    }
  }
}

Melhores práticas para transporte HTTP/SSE:

Sempre use HTTPS em produção
Implemente autenticação adequada
Use limitação de taxa
Valide e sanitize todas as entradas
Implemente timeouts adequados

Escolhendo um Transporte

5. Configuração de Clientes MCP

Diferentes clientes MCP têm requisitos de configuração variados. Aqui estão os clientes mais comuns:

5.1 Claude Desktop

O Claude Desktop é um dos clientes MCP mais populares.

Localização do arquivo de configuração:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Exemplo de configuração:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/allowed/directory"
      ]
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token"
      }
    }
  }
}

5.2 Cursor

O Cursor é um editor de código com suporte integrado a MCP.

Localização do arquivo de configuração:

macOS: ~/.cursor/mcp.json
Windows: %USERPROFILE%\.cursor\mcp.json
Linux: ~/.cursor/mcp.json

Exemplo de configuração:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost/mydb"
      ]
    }
  }
}

5.3 VS Code

O VS Code suporta MCP através de extensões.

Exemplo de configuração em settings.json:

{
  "mcp.servers": {
    "my-server": {
      "command": "python",
      "args": ["-m", "my_mcp_server"]
    }
  }
}

5.4 Clientes Personalizados

Você também pode construir seus próprios clientes MCP usando os SDKs oficiais.

Exemplo em Python:

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    server_params = StdioServerParameters(
        command="python",
        args=["-m", "my_mcp_server"]
    )
    
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            
            # Listar ferramentas disponíveis
            tools = await session.list_tools()
            print(f"Ferramentas disponíveis: {tools}")
            
            # Chamar uma ferramenta
            result = await session.call_tool(
                "my_tool",
                arguments={"param": "value"}
            )
            print(f"Resultado: {result}")

6. Segurança MCP

A segurança é crítica ao implementar servidores MCP. Aqui estão as principais considerações:

6.1 Riscos de Segurança Comuns

Execução de Código Arbitrário

Risco: Servidores MCP podem executar código arbitrário se não forem devidamente isolados.

Mitigação:

Execute servidores MCP em ambientes isolados
Use contêineres ou máquinas virtuais
Limite as permissões do sistema de arquivos
Restrinja o acesso à rede

Exposição de Dados

Risco: Servidores MCP podem expor dados sensíveis ao LLM.

Mitigação:

Implemente controles de acesso adequados
Sanitize todas as saídas
Use listas de permissões para recursos
Criptografe dados sensíveis

Injeção de Prompt

Risco: Entradas maliciosas podem manipular o comportamento do LLM.

Mitigação:

Valide e sanitize todas as entradas
Use validação de esquema
Implemente limites de taxa
Monitore padrões suspeitos

Escalonamento de Privilégios

Risco: Servidores MCP podem obter mais permissões do que o pretendido.

Mitigação:

Siga o princípio do menor privilégio
Use contas de serviço dedicadas
Implemente limites de recursos
Audite regularmente as permissões

6.2 Melhores Práticas de Segurança

Validação de Entrada

Sempre valide as entradas usando esquemas:

from pydantic import BaseModel, Field, validator

class ReadFileInput(BaseModel):
    path: str = Field(..., description="Caminho do arquivo")
    
    @validator('path')
    def validate_path(cls, v):
        # Impedir travessia de diretório
        if '..' in v:
            raise ValueError('Travessia de caminho não permitida')
        # Restringir a diretórios permitidos
        if not v.startswith('/allowed/directory'):
            raise ValueError('Acesso negado')
        return v

Autenticação e Autorização

Implemente autenticação adequada para servidores remotos:

from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials

app = FastAPI()
security = HTTPBearer()

async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
    token = credentials.credentials
    if not is_valid_token(token):
        raise HTTPException(status_code=401, detail="Token inválido")
    return token

@app.post("/mcp")
async def mcp_endpoint(token: str = Depends(verify_token)):
    # Lidar com requisição MCP
    pass

Limitação de Taxa

Implemente limitação de taxa para prevenir abuso:

from slowapi import Limiter
from slowapi.util import get_remote_address

limiter = Limiter(key_func=get_remote_address)

@app.post("/mcp")
@limiter.limit("100/minute")
async def mcp_endpoint(request: Request):
    # Lidar com requisição MCP
    pass

Logging e Monitoramento

Implemente logging e monitoramento abrangentes:

import logging
import structlog

logger = structlog.get_logger()

async def handle_tool_call(tool_name: str, arguments: dict):
    logger.info(
        "tool_call",
        tool=tool_name,
        arguments=arguments,
        timestamp=datetime.utcnow().isoformat()
    )
    
    try:
        result = await execute_tool(tool_name, arguments)
        logger.info("tool_success", tool=tool_name)
        return result
    except Exception as e:
        logger.error("tool_error", tool=tool_name, error=str(e))
        raise

6.3 Checklist de Segurança

Antes de implantar um servidor MCP, verifique:

7. Construindo um Servidor MCP

Vamos construir um servidor MCP básico usando Python.

7.1 Configuração do Projeto

Primeiro, crie um novo projeto:

mkdir my-mcp-server
cd my-mcp-server
python -m venv venv
source venv/bin/activate  # No Windows: venv\Scripts\activate
pip install mcp

7.2 Servidor Básico

Crie um arquivo server.py:

import asyncio
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent

# Criar instância do servidor
server = Server("my-mcp-server")

# Definir uma ferramenta
@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="greet",
            description="Cumprimenta uma pessoa pelo nome",
            inputSchema={
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "Nome da pessoa a cumprimentar"
                    }
                },
                "required": ["name"]
            }
        )
    ]

# Implementar a ferramenta
@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "greet":
        person_name = arguments.get("name", "Mundo")
        return [
            TextContent(
                type="text",
                text=f"Olá, {person_name}! Bem-vindo ao MCP."
            )
        ]
    raise ValueError(f"Ferramenta desconhecida: {name}")

# Executar o servidor
async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            server.create_initialization_options()
        )

if __name__ == "__main__":
    asyncio.run(main())

7.3 Adicionando Resources

Vamos adicionar suporte a resources:

from mcp.types import Resource, ResourceContents

@server.list_resources()
async def list_resources() -> list[Resource]:
    return [
        Resource(
            uri="config://app/settings",
            name="Configurações da Aplicação",
            description="Configurações atuais da aplicação",
            mimeType="application/json"
        )
    ]

@server.read_resource()
async def read_resource(uri: str) -> ResourceContents:
    if uri == "config://app/settings":
        return ResourceContents(
            uri=uri,
            mimeType="application/json",
            text='{"theme": "dark", "language": "pt"}'
        )
    raise ValueError(f"Resource desconhecido: {uri}")

7.4 Adicionando Prompts

Vamos adicionar suporte a prompts:

from mcp.types import Prompt, PromptMessage, PromptArgument

@server.list_prompts()
async def list_prompts() -> list[Prompt]:
    return [
        Prompt(
            name="code_review",
            description="Revisa código em busca de problemas",
            arguments=[
                PromptArgument(
                    name="code",
                    description="O código a ser revisado",
                    required=True
                )
            ]
        )
    ]

@server.get_prompt()
async def get_prompt(name: str, arguments: dict) -> list[PromptMessage]:
    if name == "code_review":
        code = arguments.get("code", "")
        return [
            PromptMessage(
                role="user",
                content=TextContent(
                    type="text",
                    text=f"Por favor, revise o seguinte código:\n\n{code}"
                )
            )
        ]
    raise ValueError(f"Prompt desconhecido: {name}")

7.5 Testando o Servidor

Você pode testar seu servidor usando o MCP Inspector:

npx @modelcontextprotocol/inspector python server.py

Ou escrevendo um cliente de teste:

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def test_server():
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"]
    )
    
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            
            # Testar a ferramenta greet
            result = await session.call_tool(
                "greet",
                arguments={"name": "Alice"}
            )
            print(f"Resultado: {result}")
            
            # Testar o resource
            resource = await session.read_resource("config://app/settings")
            print(f"Resource: {resource}")
            
            # Testar o prompt
            prompt = await session.get_prompt(
                "code_review",
                arguments={"code": "def hello(): pass"}
            )
            print(f"Prompt: {prompt}")

if __name__ == "__main__":
    asyncio.run(test_server())

7.6 Empacotando e Distribuindo

Para distribuir seu servidor MCP:

Crie um pyproject.toml:

[project]
name = "my-mcp-server"
version = "0.1.0"
description = "Meu servidor MCP personalizado"
dependencies = ["mcp"]

[project.scripts]
my-mcp-server = "server:main"

Publique no PyPI:

pip install build twine
python -m build
twine upload dist/*

Os usuários podem então instalá-lo e configurá-lo:

{
  "mcpServers": {
    "my-server": {
      "command": "my-mcp-server"
    }
  }
}

8. Exercícios

Exercício 1: Construa um Servidor MCP de Calculadora

Crie um servidor MCP que forneça ferramentas de calculadora:

add: Soma dois números
subtract: Subtrai dois números
multiply: Multiplica dois números
divide: Divide dois números (com tratamento de divisão por zero)

Requisitos:

Valide que as entradas são números
Trate erros graciosamente
Retorne resultados formatados adequadamente

Exercício 2: Adicione Resources a um Servidor MCP

Estenda o servidor de calculadora para incluir resources:

history://calculations: Histórico de cálculos
config://calculator: Configurações da calculadora

Requisitos:

Mantenha um histórico de cálculos
Permita que as configurações sejam lidas
Formate os dados adequadamente

Exercício 3: Implemente Segurança

Adicione recursos de segurança ao seu servidor MCP:

Validação de entrada usando esquemas
Limitação de taxa para chamadas de ferramentas
Logging de todas as operações
Tratamento de erros com mensagens apropriadas

Requisitos:

Use Pydantic para validação
Implemente limitação de taxa
Registre todas as chamadas de ferramentas
Nunca exponha detalhes internos de erro

Exercício 4: Construa um Servidor MCP Remoto

Converta seu servidor MCP para usar o transporte HTTP/SSE:

Implemente um endpoint HTTP
Adicione autenticação
Suporte múltiplos clientes
Implemente streaming adequado

Requisitos:

Use FastAPI ou similar
Implemente autenticação por token
Trate desconexões graciosamente
Adicione verificações de saúde

9. Recursos Adicionais

Documentação Oficial

Servidores MCP Populares

Recursos de Aprendizado

Ferramentas da Comunidade

Resumo do Módulo

Neste módulo, você aprendeu:

O que é MCP: Um protocolo padronizado para conectar LLMs a ferramentas e dados externos
Arquitetura MCP: Aplicações hospedeiras, clientes e servidores
Primitivos MCP: Tools, Resources e Prompts
Transportes MCP: stdio e HTTP/SSE
Configuração de Clientes: Como configurar clientes MCP populares
Segurança MCP: Riscos comuns e melhores práticas
Construindo Servidores: Como criar seu próprio servidor MCP

Próximos Passos

Agora que você entende o MCP, considere:

Construir um servidor MCP para um caso de uso específico
Contribuir com servidores MCP de código aberto
Explorar o ecossistema MCP e aprender com exemplos existentes
Manter-se atualizado com os desenvolvimentos do MCP
Compartilhar seu conhecimento com a comunidade

Perguntas Frequentes

P: O MCP é específico para algum fornecedor de LLM?

R: Não, o MCP é um padrão aberto que funciona com qualquer LLM ou cliente que o suporte.

P: Posso usar MCP com LLMs locais?

R: Sim, o MCP funciona com LLMs locais, desde que o cliente suporte o protocolo.

P: O MCP é seguro?

R: O MCP fornece um framework para interações seguras, mas a segurança depende da implementação. Siga as melhores práticas descritas neste módulo.

P: Quais linguagens posso usar para construir servidores MCP?

R: SDKs oficiais estão disponíveis para Python e TypeScript. SDKs da comunidade existem para outras linguagens.

P: Como depuro servidores MCP?

R: Use o MCP Inspector ou implemente logging abrangente em seu servidor.

P: Posso executar múltiplos servidores MCP simultaneamente?

R: Sim, os clientes podem se conectar a múltiplos servidores MCP ao mesmo tempo.

P: Qual é a diferença entre Tools e Resources?

R: Tools executam ações e podem ter efeitos colaterais, enquanto Resources fornecem dados somente leitura.

P: Como lido com autenticação em servidores MCP remotos?

R: Use autenticação baseada em token, OAuth ou outros mecanismos de autenticação padrão. Sempre use HTTPS.

P: O MCP suporta operações assíncronas?

R: Sim, o MCP suporta operações assíncronas através de seu protocolo de mensagens.

P: Como contribuo para o ecossistema MCP?

R: Construa e compartilhe servidores MCP, contribua com SDKs, escreva tutoriais ou participe de discussões da```bash python -m detector --audit --events evidence/vulnerable-persistence.jsonl

A CLI sai com `1` quando encontra algo, então funciona como verificação de CI sem
analisar a sua saída.

Nove cenários contra ambas as implementações, com invariantes de autoverificação:```bash
python scripts/scenarios.py

O relatório de incidente que um respondedor receberia, e as figuras neste README:```bash python scripts/report.py

## 🧪 Exemplos de Uso

### Exemplo 1: Análise de Segurança de Contrato Inteligente

```bash
# Analisar um contrato inteligente em busca de vulnerabilidades
python3 -m src.main --contract 0x1234567890abcdef1234567890abcdef12345678 --network ethereum

# Saída:
# ✅ Análise concluída
# 🔍 Vulnerabilidades encontradas: 3
# ⚠️  Reentrancy detectada na linha 45
# ⚠️  Integer overflow na linha 78
# ⚠️  Acesso não autorizado na linha 102


---

[Read more](https://github.com/het-p301204/afterlife)

Localização	Local	Remoto
Complexidade	Baixa	Alta
Segurança	Mais seguro por padrão	Requer configuração
Escalabilidade	Processo único	Múltiplos clientes
Caso de uso	Ferramentas locais	Serviços compartilhados

Tools	Modelo	Executar ações	Sim	Consultar APIs, modificar dados
Resources	Aplicação	Fornecer dados	Não	Ler arquivos, buscar registros
Prompts	Usuário	Guiar interações	Não	Templates de fluxo de trabalho

AfterLife

Mais Populares

Sobre

AFTERLIFE

Laboratório de Detecção de Persistência de Revogação

A ação de contenção que não contém```text

Por que isso importa

O detector ingênuo

O pacote de regras

O console

Arquitetura

Linhagem de tokens

Matriz de cenários

Falsos positivos

A correção```python

THE FIX. Two mechanisms, deliberately redundant.

O mesmo ataque, contra a correção

Não apenas palavras-passe

Compromissos arquiteturais

Porque é que um 2.1 Low é a coisa errada para discutir

Testes```text

Ciclo de Vida da Conexão

3. Primitivos MCP

3.1 Tools (Ferramentas)

3.2 Resources (Recursos)

3.3 Prompts (Prompts)

Comparando os Primitivos

4. Transportes MCP

4.1 Transporte stdio

4.2 Transporte HTTP/SSE

Escolhendo um Transporte

5. Configuração de Clientes MCP

5.1 Claude Desktop

5.2 Cursor

5.3 VS Code

5.4 Clientes Personalizados

6. Segurança MCP

6.1 Riscos de Segurança Comuns

Execução de Código Arbitrário

Exposição de Dados

Injeção de Prompt

Escalonamento de Privilégios

6.2 Melhores Práticas de Segurança

Validação de Entrada

Autenticação e Autorização

Limitação de Taxa

Logging e Monitoramento

6.3 Checklist de Segurança

7. Construindo um Servidor MCP

7.1 Configuração do Projeto

7.2 Servidor Básico

7.3 Adicionando Resources

7.4 Adicionando Prompts

7.5 Testando o Servidor

7.6 Empacotando e Distribuindo

8. Exercícios

Exercício 1: Construa um Servidor MCP de Calculadora

Exercício 2: Adicione Resources a um Servidor MCP

Exercício 3: Implemente Segurança

Exercício 4: Construa um Servidor MCP Remoto

9. Recursos Adicionais

Documentação Oficial

Servidores MCP Populares

Recursos de Aprendizado

Ferramentas da Comunidade

Resumo do Módulo

Próximos Passos

Perguntas Frequentes

P: O MCP é específico para algum fornecedor de LLM?

P: Posso usar MCP com LLMs locais?

P: O MCP é seguro?

P: Quais linguagens posso usar para construir servidores MCP?

P: Como depuro servidores MCP?

P: Posso executar múltiplos servidores MCP simultaneamente?

P: Qual é a diferença entre Tools e Resources?

P: Como lido com autenticação em servidores MCP remotos?

P: O MCP suporta operações assíncronas?

P: Como contribuo para o ecossistema MCP?