Mode FORUM_ROLES_DEPUIS_HUB=1 (désactivé par défaut) : - à chaque connexion / renouvellement de session, GET /oauth/roles et alignement des rôles locaux (adhérent, modérateur, adjoint, station) ; « proprietaire » reste fixé par FORUM_PROPRIETAIRE_ID ; le lien d'un propriétaire de station avec SA station reste local ; Hub injoignable : rôles locaux gardés. - un changement fait dans le forum (panneau du forum, adhésion acceptée) part vers le Hub en delta (relu puis modifié), sans écraser le panneau admin. - migrer_roles_hub.py : reprise idempotente des rôles de la base du forum vers le Hub (union, jamais de retrait ; simulation par défaut). Tests : tests/test_roles_hub.py. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
262 lignes
11 KiB
Python
262 lignes
11 KiB
Python
"""« Se connecter avec Gastinel » : client OAuth 2 (code + PKCE S256) vers le Hub. Bibliothèque standard seulement.
|
|
|
|
Contrat du Hub (Plan-connexion-Gastinel.md) :
|
|
GET {hub}/oauth/autoriser?response_type=code&client_id&redirect_uri&state&code_challenge&code_challenge_method=S256
|
|
POST {hub}/oauth/jeton (formulaire) grant_type=authorization_code, code, redirect_uri, client_id, code_verifier[, client_secret]
|
|
-> {"access_token", "token_type": "Bearer", "expires_in": 3600} ; erreurs {"error"} en 400/401/429
|
|
GET {hub}/oauth/moi (Authorization: Bearer <jeton>) -> {"id": "<uuid>", "pseudo": "..."} ; sinon 401 {"error": "invalid_token"}
|
|
GET {hub}/oauth/roles?id=<uuid> (Basic client_id:secret) -> {"id", "roles": [...]} ; 404 si le compte n'a jamais
|
|
utilisé le forum. Mode FORUM_ROLES_DEPUIS_HUB=1 : le Hub est la source de vérité des rôles
|
|
(gérés depuis le panneau admin) ; le forum les relit à chaque connexion / renouvellement.
|
|
POST {hub}/oauth/roles (Basic) {"id", "roles"} : remplace les rôles (gestes faits dans le forum, reprise).
|
|
|
|
Le forum ne voit jamais le mot de passe ni l'e-mail : seulement l'identifiant et le pseudo.
|
|
"""
|
|
import base64
|
|
import hashlib
|
|
import ipaddress
|
|
import json
|
|
import os
|
|
import re
|
|
import secrets
|
|
import urllib.error
|
|
import urllib.parse
|
|
import urllib.request
|
|
|
|
REPONSE_MAX = 64 * 1024 # réponse du Hub lue au plus (octets)
|
|
DELAI = 10 # secondes
|
|
ID_HUB_OK = re.compile(r"^[A-Za-z0-9_.:@-]{1,64}$")
|
|
LOCALES = [ipaddress.ip_network(n) for n in ("127.0.0.0/8", "10.0.0.0/8", "192.168.0.0/16", "::1/128")]
|
|
|
|
|
|
class ErreurHub(Exception):
|
|
"""Le Hub a refusé ou n'a pas répondu correctement."""
|
|
|
|
|
|
def _bool(v):
|
|
return str(v or "").strip() == "1"
|
|
|
|
|
|
PREFIXE_OK = re.compile(r"^(/[A-Za-z0-9._~-]+)+$")
|
|
|
|
|
|
def normaliser_prefixe(p):
|
|
"""« forum », « /forum/ » -> « /forum » ; vide -> « ». Refuse tout caractère douteux (injection dans les liens)."""
|
|
p = (p or "").strip().strip("/")
|
|
if not p:
|
|
return ""
|
|
p = "/" + p
|
|
if not PREFIXE_OK.match(p):
|
|
raise ValueError("FORUM_PREFIXE invalide : lettres, chiffres, . _ ~ - et / seulement")
|
|
return p
|
|
|
|
|
|
class Reglages:
|
|
"""Configuration de la connexion. En production : depuis les variables d'environnement (depuis_env)."""
|
|
|
|
def __init__(self, hub_url="", client_id="forum-vercors",
|
|
redirect_uri=None, client_secret="",
|
|
mode_test=False, relais=("127.0.0.1", "::1"), prefixe="", roles_depuis_hub=False):
|
|
self.prefixe = normaliser_prefixe(prefixe)
|
|
self.hub_url = (hub_url or "").rstrip("/")
|
|
if self.hub_url:
|
|
u = urllib.parse.urlparse(self.hub_url)
|
|
local = u.hostname in ("127.0.0.1", "localhost", "::1")
|
|
if u.scheme != "https" and not (u.scheme == "http" and local):
|
|
raise ValueError("FORUM_HUB_URL doit être en https (http seulement en local)")
|
|
self.client_id = client_id
|
|
self.redirect_uri = redirect_uri or "https://vercors.me%s/connexion/retour" % self.prefixe
|
|
self.client_secret = client_secret
|
|
self.mode_test = bool(mode_test)
|
|
self.relais = frozenset(relais)
|
|
# Hub = source de vérité des rôles (exige le secret client pour lire /oauth/roles).
|
|
self.roles_depuis_hub = bool(roles_depuis_hub)
|
|
|
|
@property
|
|
def configuree(self):
|
|
return bool(self.hub_url and self.client_id and self.redirect_uri)
|
|
|
|
@classmethod
|
|
def depuis_env(cls, env=None):
|
|
env = os.environ if env is None else env
|
|
secret = ""
|
|
fichier = env.get("FORUM_OAUTH_SECRET_FILE")
|
|
if fichier:
|
|
with open(fichier, encoding="utf-8") as fh:
|
|
secret = fh.read().strip()
|
|
else:
|
|
secret = env.get("FORUM_OAUTH_SECRET", "")
|
|
relais = ("127.0.0.1", "::1") + tuple(x.strip() for x in env.get("FORUM_RELAIS", "").split(",") if x.strip())
|
|
return cls(hub_url=env.get("FORUM_HUB_URL", ""),
|
|
client_id=env.get("FORUM_CLIENT_ID", "forum-vercors"),
|
|
redirect_uri=env.get("FORUM_REDIRECT_URI") or None,
|
|
prefixe=env.get("FORUM_PREFIXE", ""),
|
|
client_secret=secret,
|
|
mode_test=_bool(env.get("FORUM_MODE_TEST")),
|
|
relais=relais,
|
|
roles_depuis_hub=_bool(env.get("FORUM_ROLES_DEPUIS_HUB")))
|
|
|
|
|
|
# --- PKCE et adresse d'autorisation ------------------------------------------
|
|
def _b64(octets):
|
|
return base64.urlsafe_b64encode(octets).rstrip(b"=").decode("ascii")
|
|
|
|
|
|
def pkce():
|
|
"""Retourne (code_verifier, code_challenge S256)."""
|
|
verifier = secrets.token_urlsafe(48) # 64 caractères (RFC 7636 : 43 à 128)
|
|
return verifier, _b64(hashlib.sha256(verifier.encode("ascii")).digest())
|
|
|
|
|
|
def nouvel_etat():
|
|
return secrets.token_urlsafe(32)
|
|
|
|
|
|
def url_autorisation(r, etat, challenge):
|
|
q = urllib.parse.urlencode({"response_type": "code", "client_id": r.client_id, "redirect_uri": r.redirect_uri,
|
|
"state": etat, "code_challenge": challenge, "code_challenge_method": "S256"})
|
|
return "%s/oauth/autoriser?%s" % (r.hub_url, q)
|
|
|
|
|
|
# --- appels serveur à serveur ------------------------------------------------
|
|
class _SansRedirection(urllib.request.HTTPRedirectHandler):
|
|
def redirect_request(self, *a, **k): # un code ou un jeton ne suit jamais une redirection
|
|
return None
|
|
|
|
|
|
_OUVREUR = urllib.request.build_opener(urllib.request.ProxyHandler({}), _SansRedirection())
|
|
|
|
|
|
def _json(req):
|
|
try:
|
|
with _OUVREUR.open(req, timeout=DELAI) as rep:
|
|
brut = rep.read(REPONSE_MAX + 1)
|
|
except urllib.error.HTTPError as ex:
|
|
raise ErreurHub("le Hub a répondu %d" % ex.code)
|
|
except (urllib.error.URLError, OSError) as ex:
|
|
raise ErreurHub("Hub injoignable (%s)" % ex.__class__.__name__)
|
|
if len(brut) > REPONSE_MAX:
|
|
raise ErreurHub("réponse du Hub trop longue")
|
|
try:
|
|
d = json.loads(brut.decode("utf-8"))
|
|
except ValueError:
|
|
raise ErreurHub("réponse du Hub illisible")
|
|
if not isinstance(d, dict):
|
|
raise ErreurHub("réponse du Hub inattendue")
|
|
return d
|
|
|
|
|
|
def echanger_code(r, code, verifier):
|
|
"""Échange le code contre un jeton d'accès (POST /oauth/jeton)."""
|
|
champs = {"grant_type": "authorization_code", "code": code, "redirect_uri": r.redirect_uri,
|
|
"client_id": r.client_id, "code_verifier": verifier}
|
|
if r.client_secret:
|
|
champs["client_secret"] = r.client_secret
|
|
req = urllib.request.Request(r.hub_url + "/oauth/jeton", data=urllib.parse.urlencode(champs).encode("ascii"),
|
|
headers={"Content-Type": "application/x-www-form-urlencoded",
|
|
"Accept": "application/json"}, method="POST")
|
|
jeton = _json(req).get("access_token")
|
|
if not isinstance(jeton, str) or not jeton or len(jeton) > 4096:
|
|
raise ErreurHub("jeton absent")
|
|
return jeton
|
|
|
|
|
|
def lire_profil(r, jeton):
|
|
"""GET /oauth/moi -> (id Gastinel, pseudo)."""
|
|
req = urllib.request.Request(r.hub_url + "/oauth/moi",
|
|
headers={"Authorization": "Bearer " + jeton, "Accept": "application/json"})
|
|
d = _json(req)
|
|
ident = d.get("id", d.get("sub"))
|
|
if isinstance(ident, bool) or not isinstance(ident, (str, int)):
|
|
raise ErreurHub("identifiant absent")
|
|
ident = str(ident)
|
|
if not ID_HUB_OK.match(ident) or ident == "systeme":
|
|
raise ErreurHub("identifiant invalide")
|
|
pseudo = d.get("pseudo")
|
|
pseudo = "".join(c for c in pseudo if c.isprintable()).strip()[:60] if isinstance(pseudo, str) else ""
|
|
return ident, pseudo or "Membre"
|
|
|
|
|
|
# --- adresse du client --------------------------------------------------------
|
|
def ip_client(directe, xff, relais=("127.0.0.1", "::1")):
|
|
"""Adresse réelle du visiteur. X-Forwarded-For n'est cru que si la requête vient d'un relais de confiance
|
|
(Caddy en local) ; on prend alors la dernière adresse, celle que le relais a vue."""
|
|
if directe in relais and xff:
|
|
derniere = xff.split(",")[-1].strip()
|
|
try:
|
|
return str(ipaddress.ip_address(derniere))
|
|
except ValueError:
|
|
return directe
|
|
return directe
|
|
|
|
|
|
def est_locale(ip):
|
|
try:
|
|
a = ipaddress.ip_address(ip)
|
|
except ValueError:
|
|
return False
|
|
if getattr(a, "ipv4_mapped", None):
|
|
a = a.ipv4_mapped
|
|
return any(a.version == n.version and a in n for n in LOCALES)
|
|
|
|
|
|
def pousser_roles(r, hub_id, roles_forum):
|
|
"""POST {hub}/oauth/roles : le Hub affiche ces rôles sur la page du compte. Sans secret client, rien n'est envoyé."""
|
|
if not r.client_secret or not r.hub_url:
|
|
return
|
|
valides = ("adherent", "moderateur", "proprietaire_station", "proprietaire_adjoint", "proprietaire")
|
|
corps = json.dumps({"id": hub_id, "roles": sorted(set(x for x in roles_forum if x in valides))}).encode("utf-8")
|
|
jeton = base64.b64encode(("%s:%s" % (r.client_id, r.client_secret)).encode("utf-8")).decode("ascii")
|
|
req = urllib.request.Request(r.hub_url + "/oauth/roles", data=corps, method="POST",
|
|
headers={"Content-Type": "application/json", "Authorization": "Basic " + jeton})
|
|
try:
|
|
with _OUVREUR.open(req, timeout=DELAI):
|
|
pass
|
|
except (urllib.error.URLError, OSError):
|
|
pass # le Hub rattrapera à la prochaine connexion ou au prochain changement de rôle
|
|
|
|
|
|
ROLES_HUB = ("adherent", "moderateur", "proprietaire_station", "proprietaire_adjoint", "proprietaire")
|
|
|
|
|
|
def _basic(r):
|
|
return "Basic " + base64.b64encode(("%s:%s" % (r.client_id, r.client_secret)).encode("utf-8")).decode("ascii")
|
|
|
|
|
|
def lire_roles(r, hub_id):
|
|
"""GET {hub}/oauth/roles?id= : rôles du compte selon le Hub (liste triée, rôles connus seulement).
|
|
[] si le Hub ne connaît pas ce compte pour le forum (404) ; None si le Hub ne répond pas ou si rien n'est
|
|
configuré : l'appelant garde alors les rôles qu'il a déjà."""
|
|
if not r.client_secret or not r.hub_url or not ID_HUB_OK.match(hub_id or ""):
|
|
return None
|
|
req = urllib.request.Request(r.hub_url + "/oauth/roles?" + urllib.parse.urlencode({"id": hub_id}),
|
|
headers={"Authorization": _basic(r), "Accept": "application/json"})
|
|
try:
|
|
with _OUVREUR.open(req, timeout=DELAI) as rep:
|
|
brut = rep.read(REPONSE_MAX + 1)
|
|
except urllib.error.HTTPError as ex:
|
|
return [] if ex.code == 404 else None
|
|
except (urllib.error.URLError, OSError):
|
|
return None
|
|
try:
|
|
d = json.loads(brut[:REPONSE_MAX].decode("utf-8"))
|
|
except ValueError:
|
|
return None
|
|
rs = d.get("roles") if isinstance(d, dict) else None
|
|
if not isinstance(rs, list) or str(d.get("id", "")) != hub_id:
|
|
return None
|
|
return sorted(set(x for x in rs if isinstance(x, str) and x in ROLES_HUB))
|
|
|
|
|
|
def modifier_roles(r, hub_id, ajouts, retraits):
|
|
"""Écrit dans le Hub un changement fait dans le forum (adhésion validée, rôle donné au panneau du forum) :
|
|
relit les rôles du Hub et n'applique que le changement, sans écraser ce que le panneau admin a changé
|
|
entre-temps. Hub injoignable : rien n'est envoyé (False)."""
|
|
actuels = lire_roles(r, hub_id)
|
|
if actuels is None:
|
|
return False
|
|
nouveaux = (set(actuels) | set(ajouts)) - set(retraits)
|
|
if nouveaux != set(actuels):
|
|
pousser_roles(r, hub_id, nouveaux)
|
|
return True
|