tuxgyverandClaude Opus 5
9083525634
Le bouton et l'entrée de systray étaient conditionnés à un champ vide par défaut depuis son introduction en v0.8.0 : un poste tenu en quarantaine par le serveur n'affichait donc aucun moyen d'en sortir. La saisie ne dépend plus que de l'état du tunnel ; la fenêtre demande l'identifiant quand il manque et ne l'enregistre qu'une fois le serveur l'ayant accepté. L'état « Non géré par le serveur » disparaît au passage : le client l'affirmait à partir de sa seule configuration locale, sans rien vérifier. « Non vérifié » est la vérité tant qu'aucun code n'a été validé. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
102 lines
4.3 KiB
Python
102 lines
4.3 KiB
Python
"""Authentification auprès du serveur, après montage du tunnel.
|
|
|
|
Le tunnel qui monte ne donne accès à rien : le serveur place le pair en
|
|
quarantaine et ne laisse passer son trafic vers le réseau distant qu'une
|
|
fois un code à 6 chiffres validé. C'est ce que fait ce module.
|
|
|
|
Le code est vérifié **par le serveur**, contre un secret que cette
|
|
application ne détient pas — contrairement au MFA local d'origine, qui
|
|
validait un code qu'elle pouvait elle-même produire, et ne verrouillait
|
|
donc que sa propre interface.
|
|
|
|
L'ordre est imposé par le réseau : l'API du serveur n'est joignable que
|
|
depuis l'intérieur du tunnel. On monte donc d'abord, on s'authentifie
|
|
ensuite — le tunnel jouant le rôle d'un réseau de quarantaine tant que le
|
|
code n'est pas passé.
|
|
|
|
`urllib` plutôt qu'une bibliothèque HTTP tierce : un seul appel POST, aucune
|
|
raison d'alourdir les dépendances de l'application.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import ipaddress
|
|
import json
|
|
import urllib.error
|
|
import urllib.request
|
|
|
|
from app.core.config import Config
|
|
|
|
_TIMEOUT = 10
|
|
|
|
|
|
def api_base_url(cfg: Config) -> str:
|
|
"""URL de l'API du serveur, telle qu'atteignable depuis le tunnel.
|
|
|
|
À défaut d'URL explicite, elle est déduite de l'adresse du client : le
|
|
serveur occupe la première adresse de ce réseau (10.6.0.1 pour un client
|
|
en 10.6.0.6). C'est l'adresse la plus fiable depuis la quarantaine — elle
|
|
désigne le serveur lui-même, dont l'accès n'est jamais filtré, alors
|
|
qu'une adresse du réseau distant le serait.
|
|
"""
|
|
explicit = (cfg.wg.get("api_url") or "").strip()
|
|
if explicit:
|
|
return explicit.rstrip("/")
|
|
|
|
client_address = (cfg.wg.get("client_address") or "").split("/")[0].strip()
|
|
try:
|
|
host = ipaddress.ip_address(client_address)
|
|
except ValueError:
|
|
return ""
|
|
gateway = ipaddress.ip_address(int(host) - (int(host) & 0xFF) + 1)
|
|
return f"http://{gateway}:8000"
|
|
|
|
|
|
def authenticate(cfg: Config, code: str, username: str = "") -> tuple[bool, str]:
|
|
"""Valide un code TOTP auprès du serveur et ouvre l'accès réseau.
|
|
|
|
Retourne (succès, message). Un échec n'est jamais silencieux : sans
|
|
cette validation le tunnel reste monté mais ne mène nulle part, et
|
|
l'utilisateur doit comprendre pourquoi plutôt que de constater un
|
|
réseau inexplicablement muet.
|
|
|
|
`username` permet de fournir l'identifiant à la volée, quand il n'est pas
|
|
encore en configuration : la fenêtre de saisie le demande alors avec le
|
|
code, plutôt que de renvoyer l'utilisateur vers le panneau Administrateur
|
|
au moment précis où il cherche à ouvrir son accès. Il est enregistré
|
|
une fois le serveur l'ayant accepté.
|
|
"""
|
|
base = api_base_url(cfg)
|
|
if not base:
|
|
return False, ("Adresse du serveur d'authentification inconnue. "
|
|
"Renseignez-la dans le panneau Administrateur.")
|
|
|
|
username = (username or cfg.wg.get("vpn_username") or "").strip()
|
|
if not username:
|
|
return False, "Indiquez votre identifiant VPN."
|
|
|
|
payload = json.dumps({"username": username, "code": code}).encode("utf-8")
|
|
request = urllib.request.Request(
|
|
f"{base}/api/session", data=payload,
|
|
headers={"Content-Type": "application/json"}, method="POST",
|
|
)
|
|
try:
|
|
with urllib.request.urlopen(request, timeout=_TIMEOUT) as response:
|
|
body = json.loads(response.read().decode("utf-8"))
|
|
until = (body.get("access_until") or "").replace("T", " ")[:16]
|
|
return True, f"Accès réseau ouvert jusqu'à {until}" if until else "Accès réseau ouvert"
|
|
except urllib.error.HTTPError as exc:
|
|
# Le serveur explique lui-même le refus (code invalide, compte
|
|
# verrouillé, expiré…) : le relayer tel quel vaut mieux qu'un
|
|
# message générique qui obligerait à consulter les journaux.
|
|
try:
|
|
detail = json.loads(exc.read().decode("utf-8")).get("detail", "")
|
|
except (ValueError, OSError):
|
|
detail = ""
|
|
return False, detail or f"Authentification refusée (code {exc.code})"
|
|
except urllib.error.URLError as exc:
|
|
return False, (f"Serveur d'authentification injoignable ({base}) : "
|
|
f"{exc.reason}")
|
|
except (OSError, ValueError) as exc:
|
|
return False, f"Échec de l'authentification : {exc}"
|