feat: ajouter le forwarding dynamique SOCKS (-D)

Les redirections -L et -R existaient deja ; il manquait -D, ou le port local
ouvert se comporte comme un proxy SOCKS dont la destination est negociee par
chaque client (navigateur, curl...) plutot que fixee a l'avance.

- app/tunnels.py : implementation minimale d'un serveur SOCKS4/4a/5 (CONNECT
  uniquement, sans authentification - largement suffisant pour un usage
  local/personnel). Reutilise le meme _ForwardServer et le meme _relay() que
  -L/-R ; seul le handshake initial differe (negocie la destination au lieu
  de la recevoir en config). DIRECTION_DYNAMIC s'integre dans describe() et
  Tunnel.stop() sans code specifique supplementaire.
- TunnelDialog : nouvelle option "Dynamique - SOCKS (-D)" ; les champs
  Machine/Port de destination se masquent automatiquement pour ce mode
  (QFormLayout.setRowVisible), puisque la destination n'est pas fixee ici.

tests/test_socks_tunnel.py : verifie SOCKS5 (adresse IPv4) et SOCKS4a (nom de
domaine) avec un vrai client SOCKS et un transport SSH mocke - a d'ailleurs
revele un bug reel (decode("idna", errors="replace") leve une exception, le
codec idna ne supportant pas errors="replace") sur le chemin nom-de-domaine,
corrige ici (decode("ascii", errors="replace"), les noms d'hote SOCKS etant
de l'ASCII simple).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

app/dialogs/tunnel_dialog.py

@@ -7,9 +7,7 @@ from PySide6.QtWidgets import (
     QPushButton, QComboBox, QSpinBox, QLineEdit, QLabel, QMessageBox, QAbstractItemView,
 )
 
-from app.tunnels import (
+from app.tunnels import DIRECTION_DYNAMIC, DIRECTION_LABELS, TunnelManager, describe
-    DIRECTION_LOCAL, DIRECTION_REMOTE, DIRECTION_LABELS, TunnelManager, describe,
-)
 
 
 class TunnelDialog(QDialog):
@@ -26,7 +24,10 @@ class TunnelDialog(QDialog):
             "la connexion SSH, vers une machine joignable depuis le serveur — pratique pour "
             "atteindre un service qui n'ecoute que sur la boucle locale du serveur.<br>"
             "Une redirection <b>distante</b> fait l'inverse : un port ouvert sur le serveur est "
-            "relaye vers une machine joignable depuis votre poste."
+            "relaye vers une machine joignable depuis votre poste.<br>"
+            "Une redirection <b>dynamique</b> ouvre un proxy SOCKS sur votre poste : chaque "
+            "application qui s'y connecte choisit elle-meme sa destination, atteinte a travers "
+            "la connexion SSH (pratique pour naviguer comme si vous etiez sur le reseau du serveur)."
         )
         info.setWordWrap(True)
         layout.addWidget(info)
@@ -52,6 +53,10 @@ class TunnelDialog(QDialog):
         form.addRow("Machine de destination :", self.dest_host)
         form.addRow("Port de destination :", self.dest_port)
         layout.addLayout(form)
+        self.form = form
+
+        self.direction.currentIndexChanged.connect(self._update_dest_fields)
+        self._update_dest_fields()
 
         buttons = QHBoxLayout()
         self.add_btn = QPushButton("Ouvrir le tunnel")
@@ -69,6 +74,13 @@ class TunnelDialog(QDialog):
         self.remove_btn.clicked.connect(self.remove_tunnel)
         self.refresh()
 
+    def _update_dest_fields(self) -> None:
+        """La destination d'une redirection dynamique (-D) est negociee par
+        chaque client SOCKS : les champs n'ont pas de sens dans ce mode."""
+        has_dest = self.direction.currentData() != DIRECTION_DYNAMIC
+        self.form.setRowVisible(self.dest_host, has_dest)
+        self.form.setRowVisible(self.dest_port, has_dest)
+
     def refresh(self) -> None:
         self.tree.clear()
         for tunnel in self.manager.tunnels:
@@ -83,15 +95,14 @@ class TunnelDialog(QDialog):
         self.remove_btn.setEnabled(bool(self.manager.tunnels))
 
     def add_tunnel(self) -> None:
-        if not self.dest_host.text().strip():
+        direction = self.direction.currentData()
+        if direction != DIRECTION_DYNAMIC and not self.dest_host.text().strip():
             QMessageBox.warning(self, "Destination manquante", "Indiquez la machine de destination.")
             return
-        config = {
+        config = {"direction": direction, "listen_port": self.listen_port.value()}
-            "direction": self.direction.currentData(),
+        if direction != DIRECTION_DYNAMIC:
-            "listen_port": self.listen_port.value(),
+            config["dest_host"] = self.dest_host.text().strip()
-            "dest_host": self.dest_host.text().strip(),
+            config["dest_port"] = self.dest_port.value()
-            "dest_port": self.dest_port.value(),
-        }
         tunnel = self.manager.start(config)
         if tunnel.error:
             QMessageBox.critical(

app/tunnels.py

@@ -1,4 +1,4 @@
-"""Tunnels SSH (redirection de ports), facon `ssh -L` et `ssh -R`.
+"""Tunnels SSH (redirection de ports), facon `ssh -L`, `ssh -R` et `ssh -D`.
 
 Redirection locale (-L) : un port ouvert sur votre poste est relaye, a travers la
 connexion SSH, vers un hote joignable depuis le serveur. Typiquement pour atteindre
@@ -7,6 +7,10 @@ l'interface web d'un service qui n'ecoute que sur la boucle locale du serveur.
 Redirection distante (-R) : l'inverse, un port ouvert sur le serveur est relaye vers
 une machine joignable depuis votre poste.
 
+Redirection dynamique (-D) : un port ouvert sur votre poste se comporte comme un
+proxy SOCKS ; la destination n'est pas fixee a l'avance mais negociee par chaque
+client SOCKS (navigateur, curl...), puis atteinte a travers la connexion SSH.
+
 Chaque tunnel tourne dans son propre thread : un relais bloque ne doit gener ni
 l'interface ni les autres tunnels.
 """
@@ -21,10 +25,12 @@ import paramiko
 
 DIRECTION_LOCAL = "local"
 DIRECTION_REMOTE = "remote"
+DIRECTION_DYNAMIC = "dynamic"
 
 DIRECTION_LABELS = {
     DIRECTION_LOCAL: "Locale  (-L)",
     DIRECTION_REMOTE: "Distante (-R)",
+    DIRECTION_DYNAMIC: "Dynamique - SOCKS (-D)",
 }
 
 
@@ -33,6 +39,8 @@ def describe(tunnel: dict) -> str:
     if tunnel.get("direction") == DIRECTION_REMOTE:
         return (f"serveur:{tunnel['listen_port']}  ->  "
                 f"{tunnel['dest_host']}:{tunnel['dest_port']} (via ce poste)")
+    if tunnel.get("direction") == DIRECTION_DYNAMIC:
+        return f"SOCKS sur 127.0.0.1:{tunnel['listen_port']}  (destination negociee par le client)"
     return (f"localhost:{tunnel['listen_port']}  ->  "
             f"{tunnel['dest_host']}:{tunnel['dest_port']} (via le serveur)")
 
@@ -84,6 +92,110 @@ class _ForwardHandler(socketserver.BaseRequestHandler):
         _relay(self.request, chan)
 
 
+# ----------------------------------------------------------------------------
+# Redirection dynamique (-D) : proxy SOCKS local
+# ----------------------------------------------------------------------------
+def _recv_exact(sock: socket.socket, n: int) -> bytes:
+    """recv() ne garantit pas de renvoyer les n octets demandes en un seul appel."""
+    data = b""
+    while len(data) < n:
+        chunk = sock.recv(n - len(data))
+        if not chunk:
+            raise ConnectionError("Connexion fermee pendant la negociation SOCKS")
+        data += chunk
+    return data
+
+
+def _read_c_string(sock: socket.socket) -> bytes:
+    out = bytearray()
+    while True:
+        b = _recv_exact(sock, 1)
+        if b == b"\x00":
+            return bytes(out)
+        out += b
+
+
+def _socks5_handshake(sock: socket.socket) -> tuple[str, int] | None:
+    nmethods = _recv_exact(sock, 1)[0]
+    methods = _recv_exact(sock, nmethods) if nmethods else b""
+    if 0x00 not in methods:
+        sock.sendall(b"\x05\xff")  # aucune methode acceptable : on ne gere que "sans authentification"
+        return None
+    sock.sendall(b"\x05\x00")
+
+    _, cmd, _, atyp = _recv_exact(sock, 4)
+    if cmd != 0x01:  # seul CONNECT est pris en charge (pas BIND / UDP ASSOCIATE)
+        sock.sendall(b"\x05\x07\x00\x01" + b"\x00" * 6)
+        return None
+
+    if atyp == 0x01:
+        host = socket.inet_ntoa(_recv_exact(sock, 4))
+    elif atyp == 0x03:
+        length = _recv_exact(sock, 1)[0]
+        host = _recv_exact(sock, length).decode("ascii", errors="replace")
+    elif atyp == 0x04:
+        host = socket.inet_ntop(socket.AF_INET6, _recv_exact(sock, 16))
+    else:
+        sock.sendall(b"\x05\x08\x00\x01" + b"\x00" * 6)  # type d'adresse non supporte
+        return None
+    port = int.from_bytes(_recv_exact(sock, 2), "big")
+
+    # Adresse/port de retour a 0 : sans interet pour un CONNECT, la plupart des
+    # clients ne les utilisent pas au-dela de verifier le code de succes.
+    sock.sendall(b"\x05\x00\x00\x01" + b"\x00\x00\x00\x00\x00\x00")
+    return host, port
+
+
+def _socks4_handshake(sock: socket.socket) -> tuple[str, int] | None:
+    cmd = _recv_exact(sock, 1)[0]
+    port = int.from_bytes(_recv_exact(sock, 2), "big")
+    ip_bytes = _recv_exact(sock, 4)
+    _read_c_string(sock)  # identifiant utilisateur, ignore
+    if cmd != 0x01:
+        sock.sendall(b"\x00\x5b" + b"\x00" * 6)
+        return None
+    # SOCKS4a : une IP de la forme 0.0.0.x (x != 0) signale un nom de domaine a
+    # lire ensuite plutot qu'une adresse IP directement utilisable.
+    if ip_bytes[:3] == b"\x00\x00\x00" and ip_bytes[3] != 0:
+        host = _read_c_string(sock).decode("ascii", errors="replace")
+    else:
+        host = socket.inet_ntoa(ip_bytes)
+    sock.sendall(b"\x00\x5a" + port.to_bytes(2, "big") + ip_bytes)
+    return host, port
+
+
+def _socks_handshake(sock: socket.socket) -> tuple[str, int] | None:
+    """Negocie une requete SOCKS4/4a ou SOCKS5 (CONNECT uniquement, sans
+    authentification) et renvoie (hote, port) demande par le client, ou None si
+    la negociation echoue ou porte sur une commande non prise en charge."""
+    version = _recv_exact(sock, 1)
+    if version == b"\x05":
+        return _socks5_handshake(sock)
+    if version == b"\x04":
+        return _socks4_handshake(sock)
+    return None
+
+
+class _SocksHandler(socketserver.BaseRequestHandler):
+    transport: paramiko.Transport
+
+    def handle(self):
+        sock = self.request
+        try:
+            dest = _socks_handshake(sock)
+        except (OSError, ConnectionError, IndexError):
+            return
+        if dest is None:
+            return
+        try:
+            chan = self.transport.open_channel("direct-tcpip", dest, sock.getpeername())
+        except Exception:
+            return
+        if chan is None:
+            return
+        _relay(sock, chan)
+
+
 class Tunnel:
     """Un tunnel actif, avec de quoi l'arreter."""
 
@@ -103,9 +215,20 @@ class Tunnel:
         self._transport = transport
         if self.direction == DIRECTION_REMOTE:
             self._start_remote(transport)
+        elif self.direction == DIRECTION_DYNAMIC:
+            self._start_dynamic(transport)
         else:
             self._start_local(transport)
 
+    # ---------- redirection dynamique (-D) : proxy SOCKS ----------
+    def _start_dynamic(self, transport: paramiko.Transport) -> None:
+        config = self.config
+        handler = type("SocksHandler", (_SocksHandler,), {"transport": transport})
+        bind = config.get("listen_host") or "127.0.0.1"
+        self._server = _ForwardServer((bind, int(config["listen_port"])), handler)
+        self._thread = threading.Thread(target=self._server.serve_forever, daemon=True)
+        self._thread.start()
+
     # ---------- redirection locale (-L) ----------
     def _start_local(self, transport: paramiko.Transport) -> None:
         config = self.config

tests/test_socks_tunnel.py

@@ -0,0 +1,121 @@
+"""Tunnel dynamique (-D) : verifie que le proxy SOCKS5 / SOCKS4a negocie
+correctement la destination demandee par le client puis relaie le trafic a
+travers un (faux) transport SSH -- sans connexion SSH reelle, comme le fait
+deja test_tunnels.py pour la redirection locale."""
+import sys, pathlib
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
+
+import socket
+import threading
+import time
+
+from app.tunnels import TunnelManager, DIRECTION_DYNAMIC
+
+
+class EchoServer(threading.Thread):
+    """Serveur de destination : renvoie ce qu'il recoit, prefixe."""
+
+    def __init__(self):
+        super().__init__(daemon=True)
+        self.sock = socket.socket()
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.sock.bind(("127.0.0.1", 0))
+        self.sock.listen(5)
+        self.port = self.sock.getsockname()[1]
+
+    def run(self):
+        while True:
+            try:
+                conn, _ = self.sock.accept()
+            except OSError:
+                return
+            data = conn.recv(1024)
+            conn.sendall(b"echo:" + data)
+            conn.close()
+
+
+class FakeTransport:
+    """Imite paramiko.Transport : ouvre un vrai socket vers la destination negociee."""
+
+    def open_channel(self, kind, dest, src):
+        assert kind == "direct-tcpip"
+        return socket.create_connection(dest, timeout=5)
+
+
+def socks5_connect(proxy_port: int, host: str, port: int) -> socket.socket:
+    sock = socket.create_connection(("127.0.0.1", proxy_port), timeout=5)
+    sock.sendall(b"\x05\x01\x00")  # version 5, 1 methode proposee : "sans authentification"
+    assert sock.recv(2) == b"\x05\x00", "methode 'sans authentification' attendue"
+    sock.sendall(b"\x05\x01\x00\x01" + socket.inet_aton(host) + port.to_bytes(2, "big"))
+    reply = sock.recv(10)
+    assert reply[0:2] == b"\x05\x00", f"CONNECT refuse : {reply}"
+    return sock
+
+
+def socks4a_connect(proxy_port: int, host: str, port: int) -> socket.socket:
+    sock = socket.create_connection(("127.0.0.1", proxy_port), timeout=5)
+    # IP 0.0.0.1 = extension SOCKS4a : le nom suit l'identifiant utilisateur
+    sock.sendall(
+        b"\x04\x01" + port.to_bytes(2, "big") + b"\x00\x00\x00\x01"
+        + b"user\x00" + host.encode("ascii") + b"\x00"
+    )
+    reply = sock.recv(8)
+    assert reply[0:2] == b"\x00\x5a", f"CONNECT refuse : {reply}"
+    return sock
+
+
+echo = EchoServer()
+echo.start()
+print(f"serveur de destination (echo) sur le port {echo.port}")
+
+manager = TunnelManager(FakeTransport())
+tunnel = manager.start({"direction": DIRECTION_DYNAMIC, "listen_port": 0})
+assert tunnel.error is None, tunnel.error
+proxy_port = tunnel._server.server_address[1]
+print("proxy SOCKS ouvert sur le port", proxy_port)
+time.sleep(0.2)
+
+print()
+print("=== 1. SOCKS5, adresse IPv4 ===")
+client = socks5_connect(proxy_port, "127.0.0.1", echo.port)
+client.sendall(b"bonjour-socks5")
+reponse = client.recv(1024)
+client.close()
+print("  recu:", reponse)
+assert reponse == b"echo:bonjour-socks5", reponse
+
+print()
+print("=== 2. SOCKS4a, nom de domaine ===")
+client = socks4a_connect(proxy_port, "localhost", echo.port)
+client.sendall(b"bonjour-socks4a")
+reponse = client.recv(1024)
+client.close()
+print("  recu:", reponse)
+assert reponse == b"echo:bonjour-socks4a", reponse
+
+print()
+print("=== 3. SOCKS5 : commande non supportee (BIND) rejetee proprement ===")
+sock = socket.create_connection(("127.0.0.1", proxy_port), timeout=5)
+sock.sendall(b"\x05\x01\x00")
+assert sock.recv(2) == b"\x05\x00"
+sock.sendall(b"\x05\x02\x00\x01" + socket.inet_aton("127.0.0.1") + (1234).to_bytes(2, "big"))  # BIND
+reply = sock.recv(10)
+print("  reponse:", reply)
+assert reply[1] == 0x07, reply  # 0x07 = commande non supportee
+sock.close()
+print("  OK")
+
+print()
+print("=== 4. Fermeture du tunnel : le port SOCKS n'accepte plus de connexion ===")
+manager.stop_all()
+time.sleep(0.3)
+try:
+    socket.create_connection(("127.0.0.1", proxy_port), timeout=1).close()
+    ferme = False
+except OSError:
+    ferme = True
+assert ferme, "le port doit etre libere apres fermeture"
+print("  OK")
+
+print()
+print("SOCKS DYNAMIQUE (-D) : TOUS LES TESTS OK")