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>
This commit is contained in:
Florian
@@ -7,9 +7,7 @@ from PySide6.QtWidgets import (
|
||||
QPushButton, QComboBox, QSpinBox, QLineEdit, QLabel, QMessageBox, QAbstractItemView,
|
||||
)
|
||||
|
||||
from app.tunnels import (
|
||||
DIRECTION_LOCAL, DIRECTION_REMOTE, DIRECTION_LABELS, TunnelManager, describe,
|
||||
)
|
||||
from app.tunnels import DIRECTION_DYNAMIC, 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 = {
|
||||
"direction": self.direction.currentData(),
|
||||
"listen_port": self.listen_port.value(),
|
||||
"dest_host": self.dest_host.text().strip(),
|
||||
"dest_port": self.dest_port.value(),
|
||||
}
|
||||
config = {"direction": direction, "listen_port": self.listen_port.value()}
|
||||
if direction != DIRECTION_DYNAMIC:
|
||||
config["dest_host"] = self.dest_host.text().strip()
|
||||
config["dest_port"] = self.dest_port.value()
|
||||
tunnel = self.manager.start(config)
|
||||
if tunnel.error:
|
||||
QMessageBox.critical(
|
||||
|
||||
125
app/tunnels.py
125
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
|
||||
|
||||
Reference in New Issue
Block a user