feat: ajouter le support ProxyJump / bastion (jump host)

Une session peut desormais passer par un jump host avant d'atteindre sa
cible, avec 3 sources possibles (limite a un seul saut pour l'instant) :
une session PySSH existante, un Host de ~/.ssh/config, ou une configuration
manuelle (hote/port/utilisateur/authentification/cle).

- session_manager.py : BastionConfig (mode + parametres), champ
  Session.bastion. Jamais de mot de passe stocke : un bastion en mode "mot
  de passe" le redemande a la connexion, comme le fait deja Session.auth_type.
- app/bastion.py : resolve_bastion_target() convertit un BastionConfig en
  parametres de connexion concrets quelle que soit sa source, et leve une
  erreur claire si la reference est cassee (session supprimee, alias OpenSSH
  introuvable, config manuelle incomplete) plutot que d'echouer plus tard
  avec un message obscur.
- ssh_connection.py : la logique de connexion (auth, cle d'hote modifiee,
  mot de passe de secours en mode auto) est factorisee dans _connect_host(),
  reutilisee a l'identique pour le bastion et pour la cible.
  _open_bastion_channel() connecte d'abord le bastion puis ouvre un canal
  direct-tcpip vers la cible, passe en sock= a la connexion finale (mecanisme
  ProxyJump standard de paramiko). Le bastion a son propre SSHClient, ferme
  proprement a la fin de la connexion.
- SessionDialog : section "Bastion / Jump Host" (choix de la source + champs
  associes, caches/affiches via un QStackedWidget).
- ConnectionController resout le bastion et demande son mot de passe (si
  nécessaire) avant d'ouvrir l'onglet ; erreur affichee immediatement si la
  reference est invalide plutot que de lancer une connexion vouee a l'echec.
- app/openssh/config.py : un Host avec ProxyJump produit maintenant une
  Session dont le bastion reference cet alias (mode BASTION_OPENSSH) : le
  scenario proxmox-prod / bastion de la Phase 2 fonctionne de bout en bout.

tests/test_bastion.py (resolution des 3 sources + erreurs, et ouverture du
canal via un bastion entierement mocke, sans reseau reel) et
tests/test_session_dialog_bastion.py (UI : construction, pre-remplissage a
l'edition, resultat par mode).

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

app/ssh_connection.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 
 import queue
 import threading
-from pathlib import Path
 
 import paramiko
 from PySide6.QtCore import QThread, Signal
 
 from app.known_hosts_manager import KnownHostsStore
+from app.bastion import BastionTarget
 
 from app.paths import DATA_DIR  # noqa: E402  (chemins valables aussi en .exe)
 KNOWN_HOSTS_FILE = DATA_DIR / "known_hosts"
@@ -55,6 +55,8 @@ class SSHConnection(QThread):
         rows: int = 24,
         open_shell: bool = True,
         open_sftp_on_connect: bool = False,
+        bastion_target: BastionTarget | None = None,
+        bastion_password: str = "",
         parent=None,
     ):
         super().__init__(parent)
@@ -70,9 +72,12 @@ class SSHConnection(QThread):
         self.passphrase = passphrase
         self.cols = cols
         self.rows = rows
+        self.bastion_target = bastion_target
+        self.bastion_password = bastion_password
 
         self.client: paramiko.SSHClient | None = None
         self.channel: paramiko.Channel | None = None
+        self._bastion_client: paramiko.SSHClient | None = None
         self._stop = threading.Event()
 
         self._trust_event = threading.Event()
@@ -132,10 +137,10 @@ class SSHConnection(QThread):
         self._passphrase_event.set()
 
     # ---------- mot de passe demande en secours (appele depuis le thread SSH) ----------
-    def _ask_password(self) -> str | None:
+    def _ask_password(self, label: str | None = None) -> str | None:
         self._password_event.clear()
         self._password_result = None
-        self.password_prompt.emit(f"{self.username}@{self.host}")
+        self.password_prompt.emit(label or f"{self.username}@{self.host}")
         self._password_event.wait()  # debloque via provide_password() depuis le thread GUI
         return self._password_result
 
@@ -143,76 +148,127 @@ class SSHConnection(QThread):
         self._password_result = text or None
         self._password_event.set()
 
+    # ---------- connexion (cible ou bastion, meme logique pour les deux) ----------
+    def _new_client(self) -> paramiko.SSHClient:
+        """Client SSH pret a etre connecte : cles d'hote systeme + notre known_hosts,
+        et confirmation TOFU via cette meme SSHConnection pour une cle inconnue/modifiee."""
+        client = paramiko.SSHClient()
+        DATA_DIR.mkdir(parents=True, exist_ok=True)
+        # Les hotes deja approuves par la commande ssh (~/.ssh/known_hosts) sont
+        # reconnus : inutile de reconfirmer une empreinte que votre ssh connait deja.
+        # paramiko ne reecrit jamais ce fichier ; les nouvelles cles vont dans le notre.
+        try:
+            client.load_system_host_keys()
+        except Exception:
+            pass
+        if KNOWN_HOSTS_FILE.exists():
+            client.load_host_keys(str(KNOWN_HOSTS_FILE))
+        client.set_missing_host_key_policy(TrustPrompt(self))
+        return client
+
+    def _connect_host(
+        self, client: paramiko.SSHClient, host: str, port: int, username: str, auth_type: str,
+        key_path: str, password: str, passphrase: str, sock=None, label: str | None = None,
+    ) -> None:
+        """Connecte `client` a host:port, en gerant l'authentification, la demande
+        interactive de mot de passe de secours (mode auto) et une cle d'hote modifiee.
+        Utilise a l'identique pour la cible et pour un eventuel bastion."""
+        label = label or f"{username}@{host}"
+        auto = auth_type == "auto"
+        connect_kwargs = dict(
+            hostname=host,
+            port=port,
+            username=username,
+            timeout=15,
+            # en mode auto on se comporte comme la commande ssh : agent SSH
+            # et cles par defaut de ~/.ssh, sans rien avoir a designer
+            allow_agent=(auto or auth_type == "agent"),
+            look_for_keys=auto,
+            sock=sock,
+        )
+        if auth_type == "key":
+            if not key_path:
+                raise paramiko.SSHException(
+                    f"{label} : aucune cle privee selectionnee. Choisissez une cle, ou "
+                    "l'authentification automatique / par mot de passe."
+                )
+            connect_kwargs["pkey"] = self._load_private_key(key_path, passphrase)
+        elif auth_type == "password":
+            connect_kwargs["password"] = password
+        elif auto and password:
+            connect_kwargs["password"] = password
+
+        try:
+            try:
+                client.connect(**connect_kwargs)
+            except paramiko.AuthenticationException:
+                # Mode auto : ni l'agent ni les cles ~/.ssh n'ont convenu,
+                # on demande alors un mot de passe plutot que d'echouer.
+                if not auto or connect_kwargs.get("password"):
+                    raise
+                asked = self._ask_password(label)
+                if not asked:
+                    raise
+                connect_kwargs["password"] = asked
+                connect_kwargs["look_for_keys"] = False
+                connect_kwargs["allow_agent"] = False
+                client.connect(**connect_kwargs)
+        except paramiko.BadHostKeyException as exc:
+            # La cle presentee par le serveur ne correspond plus a celle enregistree
+            # (frequent avec des IP DHCP reattribuees a une autre machine).
+            accepted = self._ask_host_key_change(exc.hostname, exc.got_key, exc.expected_key)
+            if not accepted:
+                raise paramiko.SSHException(
+                    f"Cle d'hote modifiee refusee pour {exc.hostname} (connexion annulee)."
+                ) from exc
+            self.known_hosts.replace_host_key(exc.hostname, exc.got_key)
+            # Corrige aussi la copie en memoire utilisee par ce client pour la reconnexion
+            # (load_host_keys() fusionnerait avec l'ancienne entree encore en memoire).
+            live_keys = client.get_host_keys()
+            if exc.hostname in live_keys:
+                del live_keys[exc.hostname]
+            live_keys.add(exc.hostname, exc.got_key.get_name(), exc.got_key)
+            client.connect(**connect_kwargs)
+
+    def _open_bastion_channel(self) -> paramiko.Channel:
+        """Connexion au bastion puis canal direct-tcpip vers la cible reelle, a
+        passer en `sock=` de la connexion finale (mecanisme ProxyJump standard)."""
+        target = self.bastion_target
+        bastion_client = self._new_client()
+        label = f"{target.label} (bastion)"
+        try:
+            self._connect_host(
+                bastion_client, target.host, target.port, target.username, target.auth_type,
+                target.key_path, self.bastion_password, "", label=label,
+            )
+        except Exception as exc:  # noqa: BLE001
+            try:
+                bastion_client.close()
+            except Exception:
+                pass
+            raise paramiko.SSHException(f"Bastion {target.label} : {exc}") from exc
+
+        self._bastion_client = bastion_client
+        try:
+            return bastion_client.get_transport().open_channel(
+                "direct-tcpip", (self.host, self.port), ("127.0.0.1", 0),
+            )
+        except Exception as exc:  # noqa: BLE001
+            raise paramiko.SSHException(
+                f"Bastion {target.label} : impossible d'ouvrir un canal vers "
+                f"{self.host}:{self.port} ({exc})"
+            ) from exc
+
     # ---------- cycle de vie du thread ----------
     def run(self) -> None:
         try:
-            self.client = paramiko.SSHClient()
-            DATA_DIR.mkdir(parents=True, exist_ok=True)
-            # Les hotes deja approuves par la commande ssh (~/.ssh/known_hosts) sont
-            # reconnus : inutile de reconfirmer une empreinte que votre ssh connait deja.
-            # paramiko ne reecrit jamais ce fichier ; les nouvelles cles vont dans le notre.
-            try:
-                self.client.load_system_host_keys()
-            except Exception:
-                pass
-            if KNOWN_HOSTS_FILE.exists():
-                self.client.load_host_keys(str(KNOWN_HOSTS_FILE))
-            self.client.set_missing_host_key_policy(TrustPrompt(self))
+            self.client = self._new_client()
 
-            auto = self.auth_type == "auto"
-            connect_kwargs = dict(
-                hostname=self.host,
-                port=self.port,
-                username=self.username,
-                timeout=15,
-                # en mode auto on se comporte comme la commande ssh : agent SSH
-                # et cles par defaut de ~/.ssh, sans rien avoir a designer
-                allow_agent=(auto or self.auth_type == "agent"),
-                look_for_keys=auto,
+            sock = self._open_bastion_channel() if self.bastion_target is not None else None
+            self._connect_host(
+                self.client, self.host, self.port, self.username, self.auth_type,
+                self.key_path, self.password, self.passphrase, sock=sock,
             )
-            if self.auth_type == "key":
-                if not self.key_path:
-                    raise paramiko.SSHException(
-                        "Aucune cle privee selectionnee. Choisissez une cle, ou l'authentification "
-                        "automatique / par mot de passe."
-                    )
-                connect_kwargs["pkey"] = self._load_private_key(self.key_path, self.passphrase)
-            elif self.auth_type == "password":
-                connect_kwargs["password"] = self.password
-            elif auto and self.password:
-                connect_kwargs["password"] = self.password
-
-            try:
-                try:
-                    self.client.connect(**connect_kwargs)
-                except paramiko.AuthenticationException:
-                    # Mode auto : ni l'agent ni les cles ~/.ssh n'ont convenu,
-                    # on demande alors un mot de passe plutot que d'echouer.
-                    if not auto or connect_kwargs.get("password"):
-                        raise
-                    password = self._ask_password()
-                    if not password:
-                        raise
-                    connect_kwargs["password"] = password
-                    connect_kwargs["look_for_keys"] = False
-                    connect_kwargs["allow_agent"] = False
-                    self.client.connect(**connect_kwargs)
-            except paramiko.BadHostKeyException as exc:
-                # La cle presentee par le serveur ne correspond plus a celle enregistree
-                # (frequent avec des IP DHCP reattribuees a une autre machine).
-                accepted = self._ask_host_key_change(exc.hostname, exc.got_key, exc.expected_key)
-                if not accepted:
-                    raise paramiko.SSHException(
-                        f"Cle d'hote modifiee refusee pour {exc.hostname} (connexion annulee)."
-                    ) from exc
-                self.known_hosts.replace_host_key(exc.hostname, exc.got_key)
-                # Corrige aussi la copie en memoire utilisee par ce client pour la reconnexion
-                # (load_host_keys() fusionnerait avec l'ancienne entree encore en memoire).
-                live_keys = self.client.get_host_keys()
-                if exc.hostname in live_keys:
-                    del live_keys[exc.hostname]
-                live_keys.add(exc.hostname, exc.got_key.get_name(), exc.got_key)
-                self.client.connect(**connect_kwargs)
 
             # Ouvert ici (dans le thread) et non depuis l'interface : open_sftp() fait un
             # aller-retour reseau qui figerait la fenetre s'il etait appele au clic.
@@ -341,3 +397,8 @@ class SSHConnection(QThread):
                 self.client.close()
         except Exception:
             pass
+        try:
+            if self._bastion_client:
+                self._bastion_client.close()
+        except Exception:
+            pass