mathben/erplibre
1
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity
erplibre/script/todo/vpn_menu.py
Mathieu Benoit ea07c71e04 [FIX] vpn : juger un profil monté sur son interface, et le marquer 
Le verdict se fondait sur le seul fichier d'état, que RIEN n'efface quand
un tunnel meurt sans passer par « down » — machine redémarrée, processus
tué, session expirée. Un état laissé derrière était annoncé monté sur
l'écran même qui déclarait le processus mort et l'interface absente.

L'interface arbitre désormais : son nom vient de l'état s'il y en a un,
sinon du pilote pour ceux qui la nomment d'avance, si bien qu'un tunnel
monté hors de l'outil est vu aussi. Sshuttle n'en crée aucune, là le
processus reste seul juge. La liste des profils le marque, connecter un
profil déjà monté demande confirmation, et déconnecter un profil déjà
tombé le dit sans l'empêcher : « down » nettoie l'état laissé.

--- EN ---

The verdict rested on the state file alone, which NOTHING clears when a
tunnel dies without going through "down" — machine rebooted, process
killed, session expired. A leftover state was reported as mounted on the
very screen declaring the process gone and the interface absent.

The interface now arbitrates: its name comes from the state when there is
one, otherwise from drivers that name it in advance, so a tunnel brought
up outside the tool is seen too. Sshuttle creates none, and there the
process stays the only judge. The profile list marks it, connecting an
already-mounted profile asks first, and disconnecting an already-down one
says so without refusing: "down" clears the leftover state.

Assisted-by: Claude Opus 5
2026-09-07 23:27:35 -04:00

801 lines
33 KiB
Python
Raw Blame History

#!/usr/bin/env python3
# © 2026 TechnoLibre (http://www.technolibre.ca)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
"""Le menu VPN : profils, secrets, montée, diagnostic.
La frontière avec `script/vpn/` est nette : ici on DEMANDE (quel profil,
quelle adresse, quel PSK) et on affiche ; là-bas on décide et on exécute. Ce
fichier ne connaît ni ipsec.conf, ni xl2tpd, ni aucun chemin système.
Deux chemins d'exécution, pour une raison :
· les profils et les secrets sont manipulés EN PROCESSUS, par les modules
`script.vpn.profiles` et `script.vpn.vault` — le mot de passe maître du
coffre est déjà en mémoire ici, le redemander à un sous-processus serait
une saisie de plus à chaque geste ;
· le montage, la descente et le diagnostic passent par `script/vpn/vpn.py`
en sous-processus — ils durent, ils parlent, et ils appellent sudo. La
sortie en direct est ce qui rend un « ipsec up » suivable.
"""
import getpass
import os
import click
try:
from script.todo import todo_file_browser
except Exception:
# urwid peut manquer : le parcours devient indisponible, la saisie
# directe reste. Un menu qui ne s'ouvre plus serait pire.
todo_file_browser = None
from script.todo.todo_i18n import t
from script.vpn import anyconnect_xml, presets, profiles
from script.vpn.drivers import DRIVERS, get_driver
from script.vpn.vault import VaultError, VpnVault, secrets_to_env
# `-u` : sans lui, la sortie du script est mise en tampon par blocs dès
# qu'elle est redirigée, et une montée de tunnel de trente secondes
# n'afficherait rien avant la fin.
VPN_CLI = "./.venv.erplibre/bin/python -u ./script/vpn/vpn.py"
# Nommé pour que la clé i18n tienne sur une ligne lisible — c'est la même
# chaîne que celle du CLI, et elle est longue parce qu'elle doit dire quoi
# faire, pas seulement que quelque chose ne va pas.
# Ce qu'on dit à qui n'a reçu du site qu'une passerelle et des
# identifiants : le profil est utilisable, et le premier montage dira
# lui-même quel réseau ajouter.
NO_ROUTE_NOTE = (
"No network routed yet: this tunnel will only reach the remote host."
" Connect once — the address you get tells you which network to add."
)
# La légende de l'étoile posée sur les technologies non éprouvées. Elle dit
# ce qui manque — la confrontation au terrain — et non que le code serait
# douteux : les tests unitaires, eux, sont là.
UNPROVEN_NOTE = "never mounted against a real server: only unit tests cover it"
# Où poser un préréglage quand il n'y en a aucun. Dit les DEUX répertoires,
# parce qu'ils ne servent pas au même usage : l'un est suivi par git et ne
# doit rien porter d'identifiant, l'autre est ignoré et existe pour ça.
PRESET_LOCATION_NOTE = (
"Drop a .json file in conf/vpn_presets/ (shared, nothing identifying)"
" or in private/vpn/presets/ (git-ignored, where a site preset goes)."
)
# Ce qu'on dit quand le nom tapé désigne un profil déjà là. Dit LEQUEL des
# deux gagne, champ par champ : sans cela, on ne sait pas si rejouer un
# préréglage remet la passerelle à jour ou efface les routes ajoutées.
PRESET_REPLAYED_NOTE = (
"This profile already exists: the preset refreshes what it declares,"
" everything personal is kept."
)
# Répertoires où chercher un profil AnyConnect, dans l'ordre. Les deux
# premiers sont ceux du client de Cisco — le nom a changé entre AnyConnect
# et Secure Client. Les deux derniers parce qu'un site le distribue aussi
# par courriel ou par son portail, et le fichier atterrit alors là.
ANYCONNECT_DIRS = (
"/opt/cisco/secureclient/vpn/profile",
"/opt/cisco/anyconnect/profile",
"~/Downloads",
"~/Téléchargements",
)
# Où le client de Cisco dépose les profils qu'un site distribue. Le dire
# évite d'avoir à le chercher, et c'est le seul endroit où il se trouve
# quand le client graphique a déjà servi sur la machine.
ANYCONNECT_LOCATION_NOTE = (
"An AnyConnect profile usually sits in"
" /opt/cisco/secureclient/vpn/profile/ (or .../anyconnect/profile/)."
)
# Ce que le fichier ne dit PAS, et qu'il reste donc à régler. Le profil
# AnyConnect ne déclare pas la méthode d'authentification : c'est le
# concentrateur qui l'annonce à la connexion.
ANYCONNECT_NEXT_STEP = (
"Next step: create a profile from one of them. The .xml carries no"
" username and does not say whether the service authenticates by"
" password or by web form."
)
# Ce qu'on dit avant de proposer le greffon SSO. Il faut que la réponse
# soit éclairée : le greffon n'est utile que pour une passerelle qui exige
# un navigateur intégré, et son amont n'est plus entretenu.
SSO_HELPER_NOTE = (
"Some gateways demand an embedded browser (SAML): openconnect stops on"
" « No SSO handler » and a helper is needed for the web step. It is"
" optional, and its upstream is no longer maintained."
)
# Ce qu'on dit avant de descendre un profil qui n'est pas monté. Le geste
# garde un sens — il nettoie ce qu'un tunnel mort a laissé dans /run — et
# le taire ferait croire à une erreur de choix.
NOT_CONNECTED_NOTE = (
"This profile is not connected. Disconnecting still clears the state"
" a dead tunnel left behind."
)
MASTER_PASSWORD_WARNING = (
"The vault MASTER password is stored in the configuration in clear"
" text. Remove it and type it on demand."
)
# Les technologies se choisissent par LETTRE. Le menu qui précède numérote
# ses entrées ; une seconde liste numérotée juste après invite à retaper un
# numéro de menu — et c'est exactement ce qui s'est produit. La lettre dit
# « autre question ».
DRIVER_LETTERS = "abcdefghijklmnopqrstuvwxyz"
def _sso_helper_seen():
"""Le greffon SSO est-il déjà joignable sur cette machine ?
Interrogé au PILOTE, pour que le menu et le montage cherchent au même
endroit : deux recherches distinctes finiraient par diverger, et le
menu proposerait d'installer ce que le montage trouve déjà.
"""
driver_cls = DRIVERS.get("openconnect")
if driver_cls is None:
return True
return bool(driver_cls({"name": "check"}).sso_helper)
def match_driver(answer, names):
"""Le pilote désigné par `answer`.
Rend le nom du pilote, "" si rien ne correspond, ou la LISTE des
candidats quand c'est ambigu — le dire vaut mieux qu'en choisir un.
Trois formes, dans cet ordre : la lettre affichée ; le rang, parce que
quelqu'un tapera un chiffre et qu'il a raison de le faire vu le menu qui
précède ; et un début de libellé, parce que devant « L2TP/IPsec PSK » on
tape « L ». « open » désigne deux pilotes : celui-là est refusé en le
nommant.
"""
answer = (answer or "").strip().lower()
if not answer:
return ""
if len(answer) == 1 and answer in DRIVER_LETTERS:
index = DRIVER_LETTERS.index(answer)
if index < len(names):
return names[index]
if answer.isdigit():
index = int(answer) - 1
return names[index] if 0 <= index < len(names) else ""
matches = [
name
for name in names
if DRIVERS[name].label.lower().startswith(answer)
or name.startswith(answer)
]
if len(matches) == 1:
return matches[0]
return matches or ""
class VpnMenuMixin:
# ------------------------------------------------------------------
# Menu
# ------------------------------------------------------------------
def prompt_execute_vpn(self):
print(f"🔐 {t('VPN tunnels: connect, profiles, vault secrets')}")
choices = [
{"section": t("Connection")},
{"prompt_description": t("VPN - Connect a profile")},
{"prompt_description": t("VPN - Disconnect a profile")},
{"prompt_description": t("VPN - Status and diagnosis")},
{"section": t("Profiles & secrets")},
{
"prompt_description": t(
"VPN - Create a profile from a site preset"
)
},
{
"prompt_description": t(
"VPN - Import an AnyConnect profile (.xml)"
)
},
{"prompt_description": t("VPN - Add or edit a profile")},
{"prompt_description": t("VPN - Store secrets in the vault")},
{
"prompt_description": t(
"VPN - Show the rendered configuration (dry-run)"
)
},
{"prompt_description": t("VPN - Delete a profile")},
{"section": t("Host")},
{"prompt_description": t("VPN - Install the client packages")},
{"prompt_description": t("VPN - What can this machine do?")},
]
help_info = self.fill_help_info(choices)
while True:
status = click.prompt(help_info)
print()
if status == "0":
return False
elif status == "1":
self._vpn_connect()
elif status == "2":
self._vpn_disconnect()
elif status == "3":
self._vpn_diagnose()
elif status == "4":
self._vpn_from_preset()
elif status == "5":
self._vpn_import_anyconnect()
elif status == "6":
self._vpn_edit_profile()
elif status == "7":
self._vpn_store_secrets()
elif status == "8":
self._vpn_show_config()
elif status == "9":
self._vpn_delete_profile()
elif status == "10":
self._vpn_install()
elif status == "11":
self._vpn_check()
else:
print(t("Command not found !"))
# ------------------------------------------------------------------
# Actions déléguées au CLI
# ------------------------------------------------------------------
def _vpn_cli(self, arguments, secrets_env=None):
self.execute.exec_command_live(
f"{VPN_CLI} {arguments}",
source_erplibre=False,
new_env=secrets_env or None,
)
def _vpn_secrets_env(self, name):
"""Secrets du profil, prêts pour l'environnement du sous-processus.
Le coffre est déjà ouvert ici : le faire rouvrir par `vpn.py` ferait
retaper le mot de passe maître deux fois par connexion, puisqu'un
essai à blanc précède le montage. Rend {} quand le coffre n'est pas
joignable — `vpn.py` demandera alors lui-même, et le dira.
"""
profile = profiles.load(name)
driver_cls = get_driver(profile["driver"]) if profile else None
if driver_cls is None or not driver_cls.secret_fields:
return {}
fields = tuple(key for key, _, _ in driver_cls.secret_fields)
vault = VpnVault(self.config_file, self.kdbx_manager)
if not vault.vault_path():
return {}
try:
values = vault.read(profiles.secret_title(name), fields=fields)
except VaultError as error:
print(f"! {error}")
return {}
return secrets_to_env({key: values.get(key, "") for key in fields})
def _vpn_connect(self):
name = self._vpn_select_profile()
if not name:
return
# Remonter un tunnel qui tient rejoue toute l'authentification —
# jusqu'à un formulaire web et un second facteur — pour aboutir à
# une interface qui existait déjà.
if self._vpn_is_up(profiles.load(name)):
print(f"\n! {t('This profile is already connected.')}")
if not self._is_yes(input(f"{t('Connect it again? (y/N)')} : ")):
return
# Lu UNE fois pour les deux exécutions qui suivent.
secrets_env = self._vpn_secrets_env(name)
# Le plan d'abord, l'exécution ensuite : monter un tunnel réécrit
# /etc/ipsec.conf et la table de routage. Le voir avant coûte une
# touche et évite de découvrir une faute de frappe dans un journal.
self._vpn_cli(f"up --profile {name} --dry-run", secrets_env)
if not self._is_yes(input(f"\n{t('Run this plan? (y/N): ')}")):
return
self._vpn_cli(f"up --profile {name}", secrets_env)
def _vpn_disconnect(self):
name = self._vpn_select_profile()
if not name:
return
# « down » reste utile sur un profil déjà tombé : c'est lui qui
# efface l'état laissé dans /run par un tunnel mort sans lui. On le
# dit, on ne l'empêche pas.
if not self._vpn_is_up(profiles.load(name)):
print(f"\n! {t(NOT_CONNECTED_NOTE)}")
self._vpn_cli(f"down --profile {name}")
def _vpn_diagnose(self):
name = self._vpn_select_profile()
if name:
self._vpn_cli(f"diagnose --profile {name}")
def _vpn_show_config(self):
name = self._vpn_select_profile()
if name:
self._vpn_cli(
f"up --profile {name} --dry-run",
self._vpn_secrets_env(name),
)
def _vpn_check(self):
self._vpn_cli("check")
def _vpn_install(self):
driver_cls = self._vpn_pick_driver(None)
if driver_cls is None:
return
# La question n'est posée que pour le pilote qui peut s'en servir,
# et seulement si le greffon n'est pas déjà là : proposer
# d'installer ce qui est installé fait douter de ce qu'on lit.
options = ""
if driver_cls is DRIVERS.get("openconnect") and not _sso_helper_seen():
print(f"\n{t(SSO_HELPER_NOTE)}")
if self._is_yes(input(f"{t('Install it as well? (y/N)')} : ")):
options = " --with-sso"
print(f"\n{t('The installation requires sudo.')}")
self._vpn_cli(f"install --driver {driver_cls.name}{options}")
# ------------------------------------------------------------------
# Profils
# ------------------------------------------------------------------
@staticmethod
def _vpn_is_up(profile):
"""Ce profil porte-t-il un tunnel vivant ? Faux si on ne peut pas
savoir — un pilote retiré de la configuration ne doit pas empêcher
de lister les profils."""
driver_cls = get_driver(profile.get("driver"))
return bool(driver_cls) and driver_cls(profile).is_up()
def _vpn_select_profile(self):
"""Nom du profil choisi, "" si l'utilisateur renonce.
L'état de chaque profil est affiché, parce que la liste sert autant
à connecter qu'à déconnecter : sans lui, on descend un tunnel déjà
mort ou on remonte celui qui tient, et la sortie du CLI est la
première chose qui le dit — trop tard.
"""
all_profiles = [profiles.with_defaults(p) for p in profiles.load_all()]
if not all_profiles:
print(t("No VPN profile yet: create one first."))
return ""
for index, profile in enumerate(all_profiles, start=1):
target = (
t("all traffic")
if profile["default_route"]
else ", ".join(profile["routes"])
)
# Deux colonnes de large dans les deux cas : un emoji en occupe
# deux, et sans cela les lignes non connectées décaleraient tout
# ce qui suit.
marque = "🟢" if self._vpn_is_up(profile) else " "
print(
f"[{index}] {marque} {profile['name']:<20}"
f" {profile['server']:<26} {target}"
)
answer = input(f"{t('Profile number (0 to go back)')} : ").strip()
if not answer.isdigit() or not 1 <= int(answer) <= len(all_profiles):
if answer not in ("0", ""):
print(t("Unknown choice."))
return ""
return all_profiles[int(answer) - 1]["name"]
def _vpn_from_preset(self):
"""Crée un profil à partir d'un préréglage de site.
Le préréglage porte ce que l'établissement publie et qui est le même
pour tout le monde ; il ne reste à taper que l'identifiant. Le
formulaire est celui de `_vpn_edit_profile`, amorcé : dupliquer les
questions ici ferait vivre deux formulaires qui divergeraient au
prochain champ ajouté à un pilote.
"""
found, errors = presets.load_all()
for error in errors:
print(f"! {t('Unreadable preset: ')}{error}")
if not found:
print(t("No site preset available."))
print(f" {t(PRESET_LOCATION_NOTE)}")
return
for index, preset in enumerate(found, start=1):
print(
f"[{index}] {presets.label(preset):<34}"
f" {preset.get('server', ''):<28}"
f" {t(preset.get('hint', '') or '')}"
)
answer = input(f"{t('Preset number (0 to go back)')} : ").strip()
if not answer.isdigit() or not 1 <= int(answer) <= len(found):
if answer not in ("0", ""):
print(t("Unknown choice."))
return
preset = found[int(answer) - 1]
print(f"\n{t('An empty answer keeps the preset value.')}")
name = input(
f"{t('Profile name (lowercase, digits, - or _)')} : "
).strip()
if not name:
return
existing = profiles.load(name)
seed = presets.apply(preset, name)
if existing:
print(f"! {t(PRESET_REPLAYED_NOTE)}")
# Le PRÉRÉGLAGE gagne sur les champs qu'il déclare : rejouer un
# préréglage sur un profil existant sert à le remettre à jour
# après un déménagement de passerelle ou un groupe renommé, et
# garder l'ancienne valeur ne ferait rien de ce qu'on demande.
#
# Le reste vient du profil, parce que c'est ce qui est PERSONNEL
# et qu'aucun préréglage ne porte : l'identifiant, les routes
# ajoutées à la main, le certificat épinglé, l'adresse témoin.
#
# `k in seed` borne la reprise aux champs que le pilote du
# préréglage connaît : sur un profil qui change de technologie,
# recopier tout ferait suivre une clé WireGuard dans un profil
# OpenConnect, où rien ne la lirait jamais.
declared = set(preset) - set(presets.META_KEYS)
seed.update(
{
key: value
for key, value in existing.items()
if key in seed and key not in declared
}
)
self._vpn_edit_profile(seed=seed)
def _vpn_select_xml(self):
"""Chemin du profil `.xml`, "" si l'utilisateur renonce.
Le parcours d'abord, la saisie ensuite, parce que ni l'un ni l'autre
ne suffit : le parcours part des répertoires du client de Cisco et
n'aide pas si le fichier vient d'ailleurs ; le chemin tapé oblige à
le connaître, or personne ne retient
« /opt/cisco/secureclient/vpn/profile ».
Le parcours n'est PROPOSÉ que si un de ces répertoires existe :
l'ouvrir sur un chemin absent afficherait une liste vide, ce qui
ressemble à une panne.
"""
start = next(
(
path
for path in (os.path.expanduser(d) for d in ANYCONNECT_DIRS)
if os.path.isdir(path)
),
"",
)
if todo_file_browser is not None and start:
print(f" {t('Found')} : {start}")
if self._is_yes(input(f"{t('Browse it? (Y/n)')} : ") or "o"):
self._xml_path = ""
browser = todo_file_browser.FileBrowser(
start, self._on_xml_selected
)
browser.run_main_frame()
if self._xml_path and os.path.isfile(self._xml_path):
return self._xml_path
answer = input(f"{t('Path to the .xml profile')} : ").strip()
return os.path.expanduser(answer) if answer else ""
def _on_xml_selected(self, path):
self._xml_path = path
def _vpn_import_anyconnect(self):
"""Transforme un profil AnyConnect (`.xml`) en préréglages.
Le fichier qu'un site distribue porte déjà le nom d'hôte et le
groupe de connexion, et c'est ce dernier qui décide quel service du
concentrateur on joint. Le retaper à la main est l'occasion de se
tromper sur le seul champ qui compte.
Écrit dans `private/vpn/presets/`, jamais dans `conf/` : le fichier
nomme un établissement.
"""
print(t(ANYCONNECT_LOCATION_NOTE))
path = self._vpn_select_xml()
if not path:
return
try:
found = anyconnect_xml.parse_file(path)
except anyconnect_xml.ProfileXmlError as error:
print(f"\n✗ {error}")
return
print()
for preset in found:
print(f" {presets.label(preset)}")
print(f" {t('Gateway')} : {preset['server']}")
print(
f" {t('Connection group')} :"
f" {preset['oc_usergroup'] or t('none')}"
)
stem = os.path.splitext(os.path.basename(path))[0]
stem = presets.slug_stem(stem)
written = presets.save(found, stem)
print(f"\n✓ {t('Presets written: ')}{written}")
print(f" {t(ANYCONNECT_NEXT_STEP)}")
def _vpn_edit_profile(self, seed=None):
"""Crée ou modifie un profil, quelle que soit la technologie.
Les questions viennent du PILOTE (`form_fields`) : ce menu ne sait
pas qu'un profil L2TP a un utilisateur PPP ni qu'un profil WireGuard
a une clé de pair. Ajouter une technologie n'ajoute donc pas une
ligne ici.
Une réponse vide garde la valeur actuelle : modifier une seule route
ne doit pas obliger à ressaisir tout le reste.
`seed` amorce le formulaire avec un profil déjà rempli — un
préréglage de site. Il porte alors le nom ET la technologie, donc les
deux questions correspondantes ne sont pas posées : le préréglage y a
déjà répondu, et redemander « quelle technologie ? » invite à
contredire le seul champ qu'on ne doit pas changer.
"""
if seed is not None:
current = dict(seed)
name = current["name"]
driver_cls = get_driver(current.get("driver"))
if driver_cls is None:
print(f"✗ {t('Unknown driver: ')}{current.get('driver')}")
return
else:
name = input(
f"{t('Profile name (lowercase, digits, - or _)')} : "
).strip()
if not name:
return
current = profiles.load(name) or {"name": name}
driver_cls = self._vpn_pick_driver(current.get("driver"))
if driver_cls is None:
return
# Les défauts DU PILOTE CHOISI, pour que chaque question ait un
# défaut sensé même sur un profil qui change de technologie.
draft = profiles.with_defaults(dict(current, driver=driver_cls.name))
draft["server"] = self._vpn_ask(
t(driver_cls.server_label), draft.get("server", "")
)
# L'identité d'abord, le routage ensuite : c'est l'ordre du document
# que le site remet — passerelle, utilisateur, mot de passe, clé —
# et le routage est une question à part, à laquelle ce document ne
# répond souvent pas.
self._vpn_ask_fields(draft, driver_cls, advanced=False)
draft["routes"] = self._vpn_ask(
t("Networks to reach, comma-separated"),
", ".join(draft.get("routes", [])),
)
draft["default_route"] = self._vpn_ask_flag(
t("Send ALL traffic through the tunnel?"),
draft.get("default_route", False),
)
draft["probe"] = self._vpn_ask(
t("Witness address reachable only through the tunnel (optional)"),
draft.get("probe", ""),
)
if self._is_yes(input(f"{t('Advanced settings? (y/N)')} : ")):
if driver_cls.uses_mtu:
draft["mtu"] = self._vpn_ask(
t("MTU"), str(draft.get("mtu", 1280))
)
self._vpn_ask_fields(draft, driver_cls, advanced=True)
try:
saved = profiles.save(draft)
except profiles.ProfileError as error:
print(f"\n✗ {t('Profile refused: ')}{error}")
return
print(f"\n✓ {t('Profile saved: ')}{saved['name']}")
if not saved["routes"] and not saved["default_route"]:
print(f" {t(NO_ROUTE_NOTE)}")
if driver_cls.secret_fields:
print(f" {t('Next step: store its secrets in the vault.')}")
else:
print(
f" {t('No secret to store: this one authenticates over SSH.')}"
)
def _vpn_ask_fields(self, draft, driver_cls, advanced):
"""Déroule les champs déclarés par le pilote."""
for key, label, kind, is_advanced in driver_cls.form_fields:
if bool(is_advanced) != advanced:
continue
if kind == "flag":
draft[key] = self._vpn_ask_flag(
t(label), draft.get(key, False)
)
else:
draft[key] = self._vpn_ask(
t(label), str(draft.get(key, "") or "")
)
@staticmethod
def _vpn_pick_driver(current):
"""La technologie, par lettre, avec un conseil par ligne.
C'est la seule décision du formulaire où l'utilisateur a besoin
d'aide : le reste se déduit de ce que le site lui a donné.
Une étoile marque les technologies qu'aucun serveur réel n'a
encore validées, et une légende dit ce qu'elle signifie : la liste
montre autrement cinq choix d'apparence égale.
`[0] Retour` est là comme dans tous les menus de ce CLI : sans lui,
on est coincé dans le formulaire dès qu'on a tapé un nom de profil.
"""
names = list(DRIVERS)
if len(names) == 1:
return DRIVERS[names[0]]
default = current if current in DRIVERS else names[0]
print(f"\n{t('Which technology?')}")
unproven = False
for letter, name in zip(DRIVER_LETTERS, names):
driver_cls = DRIVERS[name]
mark = " ←" if name == default else ""
# L'étoile occupe une colonne à elle : sans cela, les lignes
# marquées décaleraient leur conseil et la liste se lirait mal.
star = " " if driver_cls.proven else "*"
unproven = unproven or not driver_cls.proven
print(
f"[{letter}] {driver_cls.label:<16}{star}"
f" {t(driver_cls.hint)}{mark}"
)
if unproven:
print(f" * {t(UNPROVEN_NOTE)}")
print(f"[0] {t('Back')}")
default_letter = DRIVER_LETTERS[names.index(default)]
answer = input(
f"{t('Choice')} [{default_letter} = {DRIVERS[default].label}] : "
).strip()
if not answer:
return DRIVERS[default]
if answer == "0":
return None
chosen = match_driver(answer, names)
if isinstance(chosen, list):
labels = ", ".join(DRIVERS[name].label for name in chosen)
print(f"{t('Several technologies match: ')}{labels}")
return None
if not chosen:
print(t("Unknown choice."))
return None
return DRIVERS[chosen]
def _vpn_delete_profile(self):
name = self._vpn_select_profile()
if not name:
return
if not self._is_yes(
input(f"{t('Delete profile')} « {name} » ? (y/N) : ")
):
return
if profiles.delete(name):
print(f"✓ {t('Profile deleted.')}")
print(f" {t('Its vault entry is kept: delete it in KeePassXC.')}")
else:
message = t(
"Not deletable here: this profile comes from a shared"
" configuration file."
)
print(f"✗ {message}")
# ------------------------------------------------------------------
# Secrets
# ------------------------------------------------------------------
def _vpn_store_secrets(self):
name = self._vpn_select_profile()
if not name:
return
profile = profiles.load(name)
driver_cls = get_driver(profile["driver"])
if driver_cls is None:
print(f"✗ {t('Unknown driver: ')}{profile['driver']}")
return
if not driver_cls.secret_fields:
print(
f"{t('No secret to store: this one authenticates over SSH.')}"
)
return
vault = VpnVault(self.config_file, self.kdbx_manager)
try:
path = vault.ensure_vault(ask=input)
except VaultError as error:
print(f"✗ {error}")
return
if not path:
print(t("No vault: nothing stored."))
return
if vault.master_password_is_stored():
print(f"\n! {t(MASTER_PASSWORD_WARNING)}")
title = profiles.secret_title(name)
fields = tuple(key for key, _, _ in driver_cls.secret_fields)
# Lu AVANT les invites, pour deux raisons : le mot de passe maître
# est alors demandé avant qu'on tape des secrets, et non après ; et
# chaque invite peut dire s'il y a déjà quelque chose derrière.
# « Une réponse vide garde la valeur en place » est un piège quand
# il n'y a rien en place.
try:
existing = vault.read(title, fields=fields)
except VaultError as error:
print(f"✗ {error}")
return
print(f"\n{t('Vault entry')} : {title}")
print(f"{t('An empty answer keeps the stored value.')}")
# Les contraintes du pilote AVANT la première invite : une borne de
# longueur annoncée après coup coûte une deuxième saisie.
for note in driver_cls(profile).secret_notes():
print(f"! {note}")
print()
values = {}
if driver_cls.user_field:
# Recopié pour que le coffre reste LISIBLE dans KeePassXC ; le
# profil reste la source de vérité de l'identifiant.
values["username"] = profile.get(driver_cls.user_field, "")
for key, label, _required in driver_cls.secret_fields:
state = t("already set") if existing.get(key) else t("empty")
secret = self._vpn_ask_secret(f"{t(label)} [{state}]")
if secret is None:
return
if secret:
values[key] = secret
try:
vault.write(title, values)
except VaultError as error:
print(f"✗ {error}")
return
print(f"\n✓ {t('Secrets stored in the vault.')}")
# Ce qui reste vide et qui est OBLIGATOIRE : le dire ici, pas au
# premier montage raté.
absents = [
t(label)
for key, label, required in driver_cls.secret_fields
if required and not (values.get(key) or existing.get(key))
]
if absents:
print(
f"✗ {t('Still missing, the tunnel will not come up: ')}"
f"{', '.join(absents)}"
)
@staticmethod
def _vpn_ask_secret(label):
"""Un secret, saisi deux fois, jamais affiché.
Deux fois parce qu'une faute de frappe dans un PSK ne se voit pas :
elle ressort en « no matching proposal » côté IKE, trois étages plus
loin, et fait chercher au mauvais endroit pendant une heure.
Rend "" pour « garder la valeur en place », None pour renoncer.
"""
first = getpass.getpass(f"{label} : ")
if not first:
return ""
if first != getpass.getpass(f"{t('Confirm')} : "):
print(f"✗ {t('The two entries differ, nothing stored.')}")
return None
return first
# ------------------------------------------------------------------
@staticmethod
def _vpn_ask_flag(label, current):
"""Question oui/non dont le défaut est la valeur ACTUELLE.
Une réponse vide garde ce qui est en place : rééditer un profil pour
changer une route ne doit pas remettre le mode de routage à zéro.
"""
answer = input(f"{label} [{'O/n' if current else 'o/N'}] : ")
answer = answer.strip().lower()
if not answer:
return bool(current)
return answer in ("y", "yes", "o", "oui")
@staticmethod
def _vpn_ask(label, default):
"""Question à réponse par défaut. Vide = on garde `default`."""
shown = f" [{default}]" if default else ""
answer = input(f"{label}{shown} : ").strip()
return answer or default
Reference in a new issue View git blame Copy permalink