fix: changelog embarqué manquant, badge hors-ligne trompeur, installeur WireGuard

- CHANGELOG.md n'était pas empaqueté par PyInstaller (datas=[]) et son
  chemin, calculé depuis __file__, ne survivait pas à l'extraction
  onefile : la page « À propos » restait vide une fois compilée. Le
  fichier est désormais embarqué (--add-data) et son chemin bascule sur
  sys._MEIPASS en mode frozen.
- Le badge de latence se basait uniquement sur un ping ICMP vers
  l'endpoint : de nombreux serveurs/pare-feux le bloquent alors que le
  tunnel WireGuard fonctionne, d'où « hors ligne » permanent. Repli sur
  l'âge du dernier handshake réel quand l'ICMP échoue.
- wgsecure.iss installe désormais WireGuard for Windows en silencieux
  (prérequis manquant jusqu'ici), au même titre que le VC++
  Redistributable ; make installer-deps télécharge les deux binaires.

app/app_info.py

@@ -7,12 +7,21 @@ seul endroit où elle est bumpée à chaque release — jamais recopiée en dur
 """
 
 import os
+import sys
 
 from app import __version__
 
-_CHANGELOG_PATH = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "CHANGELOG.md"
-)
+# En développement, CHANGELOG.md vit à la racine du dépôt, deux niveaux
+# au-dessus de ce fichier. Une fois empaqueté par PyInstaller (--onefile),
+# `__file__` pointe vers l'intérieur de l'exécutable et ce chemin n'existe
+# plus : le fichier doit alors être cherché dans `sys._MEIPASS`, le dossier
+# temporaire où l'exe extrait les données embarquées via `--add-data`.
+if getattr(sys, "frozen", False):
+    _CHANGELOG_PATH = os.path.join(getattr(sys, "_MEIPASS", ""), "CHANGELOG.md")
+else:
+    _CHANGELOG_PATH = os.path.join(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "CHANGELOG.md"
+    )
 
 APP_NAME = "WGSecure"
 TAGLINE = "Client WireGuard avec surcouche MFA TOTP, pour Linux et Windows"

app/core/wireguard.py

@@ -994,6 +994,34 @@ def ping_server(host: str, timeout: int = 2) -> int | None:
     return 0
 
 
+#: Au-delà de cet âge (s), un handshake est considéré trop ancien pour
+#: garantir que le tunnel répond encore (keepalive par défaut : 25 s).
+_HANDSHAKE_STALE_S = 150
+
+
+def ping_or_handshake(cfg: Config, timeout: int = 2) -> tuple[int | None, str]:
+    """Latence ICMP vers l'endpoint, avec repli sur l'âge du handshake.
+
+    De nombreux serveurs (ou un pare-feu en chemin) bloquent l'ICMP echo
+    tout en laissant le tunnel WireGuard fonctionner parfaitement : sans ce
+    repli, le badge de statut affichait « hors ligne » en continu sur ces
+    configurations, alors que le handshake était récent et le trafic RX/TX
+    bien réel. Retourne (valeur, source) où `source` vaut "ping" (latence
+    ICMP), "handshake" (âge du dernier handshake, tunnel sain), "stale"
+    (handshake trop ancien) ou "down" (aucune des deux sondes n'aboutit).
+    """
+    host = cfg.wg.get("server_endpoint", "")
+    ms = ping_server(host, timeout) if host else None
+    if ms is not None:
+        return ms, "ping"
+    age = last_handshake_age(cfg.wg.get("interface_name", "wgs0"))
+    if age is not None and 0 <= age <= _HANDSHAKE_STALE_S:
+        return age, "handshake"
+    if age is not None and age > _HANDSHAKE_STALE_S:
+        return age, "stale"
+    return None, "down"
+
+
 # ── Test DNS leak ─────────────────────────────────────────────────────────
 
 def dns_leak_test(cfg: Config) -> dict:

app/ui/main_window.py

@@ -414,7 +414,7 @@ class MainWindow(QMainWindow):
             return
         # `ping` bloque jusqu'à 4 s : exécuté dans le thread Qt, il faisait
         # saccader toute l'interface toutes les 10 secondes.
-        self._ping_worker = ValueWorker(wg_core.ping_server, host, 2, parent=self)
+        self._ping_worker = ValueWorker(wg_core.ping_or_handshake, self._cfg, 2, parent=self)
         self._ping_worker.done.connect(self._on_ping_done)
         # Détruire le QThread depuis `finished` et non depuis `done` : `done`
         # est émis avant la sortie de run(), un deleteLater() à ce moment
@@ -422,12 +422,20 @@ class MainWindow(QMainWindow):
         self._ping_worker.finished.connect(self._ping_worker.deleteLater)
         self._ping_worker.start()
 
-    def _on_ping_done(self, ms):
+    def _on_ping_done(self, result):
         self._ping_worker = None
+        ms, source = result if result else (None, "down")
         if not self._is_connected:
             self._set_ping_badge(None, "— ms", "offline")
-        elif ms is None:
+        elif source == "down":
             self._set_ping_badge(None, "hors ligne", "bad")
+        elif source == "stale":
+            self._set_ping_badge(None, "handshake ancien", "bad")
+        elif source == "handshake":
+            # ICMP bloqué par le serveur/pare-feu mais handshake WireGuard
+            # récent : le tunnel fonctionne, la latence réelle est juste
+            # invisible depuis ce test.
+            self._set_ping_badge(None, f"actif ({ms}s)", "medium")
         elif ms < 50:
             self._set_ping_badge(ms, f"{ms} ms", "good")
         elif ms < 200: