feat(update): mise à jour servie par le serveur, depuis l'intérieur du tunnel
Les binaires ne peuvent pas venir du dépôt Gitea : il est privé, et un jeton
embarqué dans une application distribuée est un jeton donné à tous ses
utilisateurs. Ils viennent donc du serveur WGSecure, où le contrôle d'accès
existe déjà — l'API n'est joignable que par le tunnel, et on y parvient parce
que sa clé WireGuard est déclarée. Aucun secret à embarquer.
Le serveur expose GET /api/version, qui rend la version publiée et l'empreinte
de chaque artefact, et /api/version/download/{clé} qui les sert. Le manifeste
est déposé par `make publish-updates`, avec les condensats calculés une fois à
la publication : les recalculer à chaque appel bloquerait l'API sur 125 Mo.
`ANNOUNCE=` permet d'annoncer les artefacts sous un autre numéro, pour exercer
la chaîne sans compiler une seconde version.
Rien ne s'installe sans un clic. La vérification est automatique — au montage
du tunnel puis toutes les demi-heures, car ne la faire qu'au montage laissait
un serveur momentanément injoignable annuler toute proposition pour la session
— mais le téléchargement attend le bouton. Cette application monte un VPN, et
une version défaillante qui se propagerait seule couperait l'accès d'un parc
entier sans que personne ne l'ait demandé.
L'artefact est vérifié contre son empreinte SHA-256 avant d'être mis en place,
et le fichier temporaire est détruit à la moindre anomalie. Le canal est déjà
authentifié par WireGuard ; le condensat couvre ce qu'il ne couvre pas — un
téléchargement tronqué, un disque plein, un artefact mal publié.
Sous Linux, le binaire est remplacé par renommage, sur le même système de
fichiers que sa destination. Un déplacement depuis /tmp se rabattait sur une
copie, donc sur une écriture dans l'exécutable en cours, que le noyau refuse
(ETXTBSY). Un renommage ne touche qu'une entrée de répertoire : l'ancien inode
reste vivant pour le processus, qui continue jusqu'à sa fermeture — et
l'application propose désormais de redémarrer plutôt que de le laisser deviner.
Sous Windows, l'installation passe par le service, qui tourne en LocalSystem et
écrit dans Program Files sans invite d'élévation. La commande `apply_update` ne
prend aucun paramètre : le service lit le manifeste, télécharge et vérifie
lui-même. Lui passer un fichier déjà téléchargé aurait donné à tout compte du
poste — le pipe est ouvert aux utilisateurs interactifs — le moyen de faire
exécuter ce qu'il veut avec les privilèges du système.
L'installeur orchestre le remplacement, ce qu'il ne faisait pas : les deux
exécutables à remplacer tournent au moment de la mise à jour, et Windows
verrouille l'image d'un processus vivant. Il ferme donc l'application par le
gestionnaire de redémarrage, arrête les tunnels et le service avant la copie —
en attendant la libération réelle du fichier, `sc stop` rendant la main avant
la fin de l'arrêt — et garde `restartreplace` en secours. Le service, lui,
lance l'installeur détaché et ne l'attend pas : il lui demande de se remplacer
lui-même.
Durcissement du service au passage. Le premier appelant devient propriétaire et
son SID est retenu ; ensuite seuls ce compte et les administrateurs sont
servis. Le pipe étant ouvert à tout utilisateur interactif, n'importe quel
compte du poste pouvait jusqu'ici couper le tunnel d'un autre ou poser une
règle NRPT valable pour toute la machine. Le contenu d'un `.conf` est également
vérifié — seul son chemin l'était — et les directives exécutables y sont
refusées.
Corrige enfin un défaut de compilation : Linux et Windows partageaient le
répertoire de travail de PyInstaller, que `--clean` vide au démarrage. Lancées
à la suite, les deux cibles effaçaient mutuellement leurs fichiers
intermédiaires, produisant un .exe gonflé de 44 Mo et un binaire Linux tronqué
dont l'archive ne se décompressait plus.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
tuxgyver
co-authored by
Claude Opus 5
Claude Opus 5
parent
414144560e
commit
e520e30716
+278
-3
@@ -1,5 +1,8 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import subprocess
|
||||
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
from PyQt6.QtWidgets import (
|
||||
@@ -7,9 +10,9 @@ from PyQt6.QtWidgets import (
|
||||
QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
|
||||
QLabel, QPushButton, QFrame, QMessageBox, QInputDialog,
|
||||
QLineEdit, QListWidget, QListWidgetItem,
|
||||
QComboBox,
|
||||
QComboBox, QProgressBar,
|
||||
)
|
||||
from PyQt6.QtCore import Qt, QTimer, QDateTime, QEvent
|
||||
from PyQt6.QtCore import Qt, QTimer, QDateTime, QEvent, pyqtSignal
|
||||
from PyQt6.QtGui import QFont, QCloseEvent, QColor
|
||||
|
||||
from app.core.config import Config
|
||||
@@ -19,6 +22,9 @@ from app.core import log as conn_log
|
||||
from app.core import history as hist
|
||||
from app.core import shutdown as shutdown_guard
|
||||
from app.core import vpn_session
|
||||
from app.core import updater
|
||||
from app.utils.platform_utils import is_windows
|
||||
from app import __version__ as app_version
|
||||
from app.ui.worker import TaskWorker, ValueWorker
|
||||
from app.ui.access_code_dialog import AccessCodeDialog
|
||||
from app.ui.admin_window import AdminWindow
|
||||
@@ -43,9 +49,22 @@ _ACCESS_UNKNOWN_BEFORE_CLOSE = 3
|
||||
# devait être proposée. Le tunnel vient de monter : ses routes peuvent n'être
|
||||
# pas encore posées, et la fenêtre surgirait pour un code déjà valide.
|
||||
_PROBE_RETRY_MS = 3000
|
||||
# Intervalle entre deux interrogations du serveur de mise à jour. La question
|
||||
# ne se posait qu'à l'instant précis où le tunnel montait : un serveur pas
|
||||
# encore joignable à cette seconde-là — routes non posées, quarantaine en
|
||||
# cours — et plus rien n'était proposé de toute la session, sans que rien ne
|
||||
# le dise. Un intervalle unique plutôt que deux rythmes : `check` rend `None`
|
||||
# aussi bien quand le serveur se tait que lorsqu'il n'a rien de neuf, et les
|
||||
# distinguer demanderait de changer sa signature pour un gain de cadence nul.
|
||||
_UPDATE_RECHECK = timedelta(minutes=30)
|
||||
|
||||
|
||||
class MainWindow(QMainWindow):
|
||||
# Émis depuis le thread de téléchargement : passer par un signal est la
|
||||
# seule façon sûre de toucher un widget depuis un autre thread que celui
|
||||
# de l'interface.
|
||||
update_progress = pyqtSignal(int, int)
|
||||
|
||||
def __init__(self, config: Config, parent=None):
|
||||
super().__init__(parent)
|
||||
self._cfg = config
|
||||
@@ -88,6 +107,16 @@ class MainWindow(QMainWindow):
|
||||
# Conservée après fermeture : la fenêtre reste parentée à celle-ci, et
|
||||
# son thread doit être attendu avant destruction (cf. prepare_quit).
|
||||
self._access_dialog: AccessCodeDialog | None = None
|
||||
# Mise à jour : proposée, jamais imposée. `_update_dismissed` ne dure
|
||||
# que la session — une version écartée d'un clic distrait se
|
||||
# represente au prochain démarrage plutôt que d'être perdue.
|
||||
self._update_worker: ValueWorker | None = None
|
||||
self._update = None
|
||||
self._update_dismissed = False
|
||||
# Date du dernier échange abouti avec le serveur de mise à jour, et
|
||||
# non de la dernière tentative : un échec doit être réessayé vite, une
|
||||
# réponse obtenue peut attendre.
|
||||
self._update_checked_at: datetime | None = None
|
||||
self._reconnect_failures = 0
|
||||
self._quitting = False
|
||||
self._warned_foreign: set[str] = set()
|
||||
@@ -154,12 +183,251 @@ class MainWindow(QMainWindow):
|
||||
root.setSpacing(0)
|
||||
|
||||
root.addWidget(self._build_header())
|
||||
root.addWidget(self._build_update_banner())
|
||||
root.addWidget(self._build_status_action())
|
||||
root.addWidget(self._build_details())
|
||||
|
||||
# ── Pied de page ─────────────────────────────────────────────────
|
||||
root.addWidget(self._build_footer())
|
||||
|
||||
def _build_update_banner(self) -> QWidget:
|
||||
"""Bandeau proposant une mise à jour, masqué le reste du temps.
|
||||
|
||||
Placé sous l'en-tête et non dans le panneau de détails : une version
|
||||
disponible se rate si elle attend qu'on déplie quelque chose. Il
|
||||
n'apparaît qu'une fois le serveur consulté, ne se réaffiche pas dans
|
||||
la session si l'utilisateur l'écarte, et n'installe rien sans clic.
|
||||
"""
|
||||
self._update_banner = QWidget()
|
||||
self._update_banner.setStyleSheet(
|
||||
f"background: {theme.WARN_BG}; border-radius: 4px;")
|
||||
# Non parenté au bandeau : il reçoit plus bas un layout vertical qui
|
||||
# empile cette ligne et la barre de progression.
|
||||
row = QHBoxLayout()
|
||||
row.setContentsMargins(10, 6, 10, 6)
|
||||
row.setSpacing(6)
|
||||
self._update_label = QLabel("")
|
||||
self._update_label.setWordWrap(True)
|
||||
# Blanc plutôt que le jaune du bandeau : sur ce fond, le texte
|
||||
# d'avertissement passait pour du décor et se lisait mal.
|
||||
self._update_label.setStyleSheet(
|
||||
f"color: {theme.TEXT}; font-size: 11px; background: transparent;")
|
||||
row.addWidget(self._update_label, 1)
|
||||
|
||||
self._btn_update = QPushButton("MAJ")
|
||||
self._btn_update.setFixedHeight(24)
|
||||
self._btn_update.setStyleSheet(
|
||||
f"QPushButton {{ background: {theme.OK_SOLID}; color: white;"
|
||||
" font-weight: bold; border: none; border-radius: 4px;"
|
||||
" padding: 0 14px; }"
|
||||
f"QPushButton:hover {{ background: {theme.OK_HOVER}; }}"
|
||||
f"QPushButton:disabled {{ background: {theme.BG_RAISED};"
|
||||
f" color: {theme.TEXT_FAINT}; }}")
|
||||
self._btn_update.clicked.connect(self._install_update)
|
||||
row.addWidget(self._btn_update)
|
||||
|
||||
# Report : une croix, pas un mot. Elle dit « pas maintenant » sans
|
||||
# entrer en concurrence de lecture avec l'action principale.
|
||||
btn_later = QPushButton("✕")
|
||||
btn_later.setFixedSize(24, 24)
|
||||
btn_later.setToolTip("Reporter — la proposition reviendra au prochain "
|
||||
"démarrage")
|
||||
btn_later.setStyleSheet(
|
||||
f"QPushButton {{ background: {theme.FAIL_SOLID}; color: white;"
|
||||
" font-weight: bold; border: none; border-radius: 4px; }"
|
||||
f"QPushButton:hover {{ background: {theme.FAIL_HOVER}; }}")
|
||||
btn_later.clicked.connect(self._dismiss_update)
|
||||
row.addWidget(btn_later)
|
||||
|
||||
# Le téléchargement porte sur une centaine de mégaoctets : sans rien
|
||||
# à l'écran, l'application paraissait figée et l'utilisateur ne
|
||||
# pouvait pas distinguer une attente d'un échec.
|
||||
self._update_progress = QProgressBar()
|
||||
self._update_progress.setFixedHeight(6)
|
||||
self._update_progress.setTextVisible(False)
|
||||
self._update_progress.setStyleSheet(
|
||||
f"QProgressBar {{ border: none; border-radius: 3px;"
|
||||
f" background: {theme.BG}; }}"
|
||||
f"QProgressBar::chunk {{ background: {theme.OK_SOLID};"
|
||||
" border-radius: 3px; }")
|
||||
self._update_progress.setVisible(False)
|
||||
outer = QVBoxLayout()
|
||||
outer.setContentsMargins(0, 0, 0, 0)
|
||||
outer.setSpacing(4)
|
||||
inner = QWidget()
|
||||
inner.setLayout(row)
|
||||
inner.setStyleSheet("background: transparent;")
|
||||
outer.addWidget(inner)
|
||||
outer.addWidget(self._update_progress)
|
||||
self._update_banner.setLayout(outer)
|
||||
|
||||
self.update_progress.connect(self._on_download_progress)
|
||||
self._update_banner.setVisible(False)
|
||||
return self._update_banner
|
||||
|
||||
def _on_download_progress(self, recu: int, total: int):
|
||||
"""Avancement du téléchargement, reçu du thread qui le mène."""
|
||||
if total > 0:
|
||||
self._update_progress.setRange(0, total)
|
||||
self._update_progress.setValue(recu)
|
||||
self._btn_update.setText(f"{100 * recu // total} %")
|
||||
else:
|
||||
# Total inconnu : barre en va-et-vient plutôt qu'une jauge figée
|
||||
# à zéro, qui se lit comme une panne.
|
||||
self._update_progress.setRange(0, 0)
|
||||
|
||||
def _update_due(self) -> bool:
|
||||
"""Faut-il (re)demander au serveur s'il propose une version ?
|
||||
|
||||
Deux rythmes : rapide tant que le serveur n'a rien répondu, lent une
|
||||
fois qu'il a parlé. Une mise à jour déjà proposée, ou écartée pour la
|
||||
session, ne se redemande pas.
|
||||
"""
|
||||
if self._update is not None or self._update_dismissed:
|
||||
return False
|
||||
if self._update_checked_at is None:
|
||||
return True
|
||||
return (datetime.now(timezone.utc)
|
||||
- self._update_checked_at) >= _UPDATE_RECHECK
|
||||
|
||||
def _check_update(self):
|
||||
"""Interroge le serveur, sans bloquer ni déranger si rien n'est trouvé."""
|
||||
if self._update_worker is not None or self._update_dismissed:
|
||||
return
|
||||
self._update_worker = ValueWorker(updater.check, self._cfg,
|
||||
app_version, parent=self)
|
||||
self._update_worker.done.connect(self._on_update_checked)
|
||||
self._update_worker.finished.connect(self._update_worker.deleteLater)
|
||||
self._update_worker.start()
|
||||
|
||||
def _on_update_checked(self, found):
|
||||
self._update_worker = None
|
||||
self._update = found
|
||||
self._update_checked_at = datetime.now(timezone.utc)
|
||||
if found is None or self._update_dismissed:
|
||||
return
|
||||
taille = f"{found.size / 1048576:.0f} Mo" if found.size else ""
|
||||
self._update_label.setText(
|
||||
f"⬆️ Version {found.version} disponible"
|
||||
+ (f" ({taille})" if taille else ""))
|
||||
self._update_banner.setVisible(True)
|
||||
self._sync_window_height()
|
||||
self._add_log(f"Version {found.version} disponible sur le serveur",
|
||||
"info")
|
||||
|
||||
def _dismiss_update(self):
|
||||
"""Écarte la proposition pour cette session, sans la refuser à jamais.
|
||||
|
||||
Rien n'est écrit : au prochain démarrage la question se repose, et une
|
||||
version ignorée par mégarde n'est pas perdue pour toujours.
|
||||
"""
|
||||
self._update_dismissed = True
|
||||
self._update_banner.setVisible(False)
|
||||
self._sync_window_height()
|
||||
|
||||
def _install_update(self):
|
||||
"""Télécharge puis installe, après confirmation explicite."""
|
||||
if self._update is None or self._update_worker is not None:
|
||||
return
|
||||
reponse = QMessageBox.question(
|
||||
self, "Mettre à jour WGSecure",
|
||||
f"Installer la version {self._update.version} ?\n\n"
|
||||
f"Le fichier sera téléchargé depuis le serveur, puis vérifié "
|
||||
f"contre l'empreinte qu'il annonce avant d'être installé.",
|
||||
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
|
||||
QMessageBox.StandardButton.No)
|
||||
if reponse != QMessageBox.StandardButton.Yes:
|
||||
return
|
||||
|
||||
self._btn_update.setEnabled(False)
|
||||
self._btn_update.setText("…")
|
||||
self._update_progress.setRange(0, 0) # va-et-vient tant que rien
|
||||
self._update_progress.setVisible(True) # n'est encore reçu
|
||||
self._sync_window_height()
|
||||
self._update_worker = ValueWorker(self._download_and_apply,
|
||||
self._update, parent=self)
|
||||
self._update_worker.done.connect(self._on_update_installed)
|
||||
self._update_worker.finished.connect(self._update_worker.deleteLater)
|
||||
self._update_worker.start()
|
||||
|
||||
def _download_and_apply(self, info):
|
||||
"""Exécuté hors du thread graphique : 125 Mo, puis remplacement.
|
||||
|
||||
Rend le message à montrer, ou le relaie préfixé — `ValueWorker` avale
|
||||
les exceptions en rendant `None`, ce qui ne dirait pas ce qui a échoué.
|
||||
"""
|
||||
try:
|
||||
if is_windows():
|
||||
# Le service fait tout : il télécharge et vérifie lui-même,
|
||||
# pour qu'aucun compte du poste ne puisse lui faire installer
|
||||
# un fichier de son choix avec les privilèges du système.
|
||||
return updater.apply_via_helper(self._cfg)
|
||||
cible = updater.current_binary()
|
||||
archive = updater.download(
|
||||
self._cfg, info,
|
||||
progress=lambda recu, total: self.update_progress.emit(recu, total),
|
||||
dest_dir=os.path.dirname(cible) if cible else "")
|
||||
return updater.apply_update(archive)
|
||||
except Exception as exc: # noqa: BLE001 — remonté à l'UI
|
||||
return f"ERREUR: {exc}"
|
||||
|
||||
def _on_update_installed(self, message):
|
||||
self._update_worker = None
|
||||
self._btn_update.setEnabled(True)
|
||||
self._btn_update.setText("MAJ")
|
||||
self._update_progress.setVisible(False)
|
||||
self._sync_window_height()
|
||||
texte = message or "Échec inattendu de la mise à jour."
|
||||
if texte.startswith("ERREUR: "):
|
||||
texte = texte[8:]
|
||||
self._add_log(f"Mise à jour : {texte}", "error")
|
||||
QMessageBox.warning(self, "Mise à jour impossible", texte)
|
||||
return
|
||||
self._add_log(texte, "success")
|
||||
self._update_banner.setVisible(False)
|
||||
self._sync_window_height()
|
||||
QMessageBox.information(self, "Mise à jour", texte)
|
||||
|
||||
# Sous Windows, l'installeur tourne déjà et attend que les fichiers se
|
||||
# libèrent : rester ouvert le ferait patienter jusqu'à son délai, puis
|
||||
# échouer. On rend donc la main tout de suite — `prepare_quit` démonte
|
||||
# le tunnel et restaure le DNS avant de fermer, ce qui laisse aussi le
|
||||
# service du tunnel arrêtable par l'installeur.
|
||||
if is_windows():
|
||||
self._add_log("Fermeture pour laisser l'installeur remplacer les "
|
||||
"fichiers", "warning")
|
||||
self.prepare_quit()
|
||||
QApplication.quit()
|
||||
return
|
||||
|
||||
# Sous Linux, le binaire est déjà remplacé et l'application continue de
|
||||
# tourner sur l'ancien, que le noyau garde en vie. Rien n'oblige à
|
||||
# fermer — mais le dire sans rien proposer laissait l'utilisateur
|
||||
# devant une version périmée sans savoir quoi faire.
|
||||
cible = updater.current_binary()
|
||||
if not cible:
|
||||
return
|
||||
if QMessageBox.question(
|
||||
self, "Redémarrer WGSecure",
|
||||
"La nouvelle version est en place. Redémarrer maintenant ?\n\n"
|
||||
"Le tunnel sera coupé le temps du redémarrage.",
|
||||
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
|
||||
QMessageBox.StandardButton.Yes
|
||||
) != QMessageBox.StandardButton.Yes:
|
||||
return
|
||||
try:
|
||||
# Lancé détaché : sans cela le nouveau processus mourrait avec
|
||||
# celui-ci, qui s'apprête justement à disparaître.
|
||||
subprocess.Popen([cible], start_new_session=True,
|
||||
stdin=subprocess.DEVNULL,
|
||||
stdout=subprocess.DEVNULL,
|
||||
stderr=subprocess.DEVNULL)
|
||||
except OSError as exc:
|
||||
QMessageBox.warning(self, "Redémarrage impossible", str(exc))
|
||||
return
|
||||
self.prepare_quit()
|
||||
QApplication.quit()
|
||||
|
||||
# ── Section repliable : tout ce qui n'est pas statut/action ──────────
|
||||
def _build_details(self) -> QWidget:
|
||||
self._details = QWidget()
|
||||
@@ -763,6 +1031,11 @@ class MainWindow(QMainWindow):
|
||||
# hors de l'application. Demander au serveur avant de conclure
|
||||
# quoi que ce soit : lui seul sait si l'accès est encore ouvert.
|
||||
self._probe_access(prompt_if_closed=False)
|
||||
# Le serveur de mise à jour n'est joignable que par le
|
||||
# tunnel : la question ne se pose qu'une fois celui-ci monté.
|
||||
QTimer.singleShot(2000, self._check_update)
|
||||
elif self._update_due():
|
||||
self._check_update()
|
||||
elif self._access_open and self._access_stale():
|
||||
# Accès cru ouvert : le reconfirmer périodiquement, une
|
||||
# révocation côté serveur n'étant annoncée par rien.
|
||||
@@ -1231,7 +1504,8 @@ class MainWindow(QMainWindow):
|
||||
|
||||
# Laisser les threads en cours se terminer avant de démonter le tunnel :
|
||||
# une connexion et une déconnexion simultanées laisseraient un état mixte.
|
||||
for worker in (self._worker, self._ping_worker, self._probe_worker):
|
||||
for worker in (self._worker, self._ping_worker, self._probe_worker,
|
||||
self._update_worker):
|
||||
try:
|
||||
if worker is not None and worker.isRunning():
|
||||
worker.wait(15000)
|
||||
@@ -1246,6 +1520,7 @@ class MainWindow(QMainWindow):
|
||||
self._worker = None
|
||||
self._ping_worker = None
|
||||
self._probe_worker = None
|
||||
self._update_worker = None
|
||||
|
||||
if self._session_id is not None:
|
||||
hist.end_session(self._session_id, self._prev_rx or 0,
|
||||
|
||||
Reference in New Issue
Block a user