squad-manager/konto.py
danny a5da53d373 1.7.0: Mitmachen im Squad ohne Konto
Der Squad-Reiter braucht kein Konto mehr: Spielername eingeben, der PC
bekommt einen Schluessel (Token ohne Ablauf), die Akten werden fuer alle
sichtbar. E-Mail und Passwort sind optional ("Konto sichern") und machen
die Charaktere reset- und mehr-PC-fest. Ohne gesichertes Konto bietet das
Menue kein Abmelden, weil das den Schluessel loeschte.

Server: Aktionen mitmachen und konto_sichern, Konten ohne E-Mail
(Datenbank-Stand 2, eingespielt von DB::migrieren() bei der ersten
Anfrage), Loeschen ohne Passwort fuer reine Schluessel-Konten, Verwaltung
zeigt sie als "nur Schluessel". Deinstallationsfrage nennt den Schluessel.

Tests: Server 108, Zwei-PC 34, Oberflaeche 24 - auch gegen das Paket.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-15 06:35:54 +02:00

249 lines
8.6 KiB
Python

"""
Verbindung zum Server sva.tyrveil.com: Konto, Akten und Squads.
Ohne tkinter. Alle Aufrufe blockieren und gehoeren in einen
Hintergrund-Thread (siehe hintergrund.py).
Das Sitzungstoken liegt in %APPDATA%\\SquadManager\\konto.json, mit der
Windows-Datenschutz-API (DPAPI) an das Windows-Konto gebunden: Eine auf
einen anderen Rechner kopierte Datei ist dort wertlos.
"""
import base64
import ctypes
import ctypes.wintypes as wintypes
import json
import os
import socket
import threading
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
# Fuer Tests laesst sich ein lokaler Server einsetzen, nur ueber http://127.0.0.1
SERVER = os.environ.get("SM_SERVER", "https://sva.tyrveil.com").rstrip("/")
KONTO_DATEI = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "konto.json"
ZEITLIMIT = 25
class ServerFehler(Exception):
"""Fehler vom oder auf dem Weg zum Server, mit Code und lesbarer Meldung."""
def __init__(self, code, meldung, http=0, extra=None):
super().__init__(meldung)
self.code = code
self.meldung = meldung
self.http = http
self.extra = extra or {}
def _adresse_pruefen():
teile = urllib.parse.urlsplit(SERVER)
if teile.scheme == "https":
return
if teile.scheme == "http" and teile.hostname in ("127.0.0.1", "localhost"):
return
raise ServerFehler("unsicher", "Der Server muss über HTTPS erreichbar sein.")
# -- Token geschuetzt ablegen ------------------------------------------------
class _BLOB(ctypes.Structure):
_fields_ = [("cbData", wintypes.DWORD), ("pbData", ctypes.POINTER(ctypes.c_char))]
def _dpapi(daten, schuetzen):
crypt32 = ctypes.WinDLL("crypt32", use_last_error=True)
kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
funktion = crypt32.CryptProtectData if schuetzen else crypt32.CryptUnprotectData
funktion.argtypes = (ctypes.POINTER(_BLOB), ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(_BLOB))
funktion.restype = wintypes.BOOL
kernel32.LocalFree.argtypes = (ctypes.c_void_p,)
puffer = ctypes.create_string_buffer(daten, len(daten))
ein = _BLOB(len(daten), ctypes.cast(puffer, ctypes.POINTER(ctypes.c_char)))
aus = _BLOB()
CRYPTPROTECT_UI_FORBIDDEN = 0x01
if not funktion(ctypes.byref(ein), None, None, None, None, CRYPTPROTECT_UI_FORBIDDEN, ctypes.byref(aus)):
raise OSError(ctypes.get_last_error(), "DPAPI")
try:
return ctypes.string_at(aus.pbData, aus.cbData)
finally:
kernel32.LocalFree(ctypes.cast(aus.pbData, ctypes.c_void_p))
_sperre = threading.Lock()
_sitzung = None
_geladen = False
def sitzung():
"""Die gespeicherte Anmeldung {"token", "nutzer"} oder None."""
global _sitzung, _geladen
with _sperre:
if not _geladen:
_geladen = True
try:
roh = json.loads(KONTO_DATEI.read_text(encoding="utf-8"))
# Eine Anmeldung gilt nur fuer den Server, bei dem sie entstand
if roh.get("server") == SERVER:
token = _dpapi(base64.b64decode(roh["token"]), False).decode("ascii")
_sitzung = {"token": token, "nutzer": roh.get("nutzer") or {}}
except (OSError, ValueError, KeyError, TypeError):
_sitzung = None
return dict(_sitzung) if _sitzung else None
def _merken(token, nutzer):
global _sitzung, _geladen
KONTO_DATEI.parent.mkdir(parents=True, exist_ok=True)
zwischen = KONTO_DATEI.with_suffix(".tmp")
zwischen.write_text(json.dumps({
"server": SERVER,
"token": base64.b64encode(_dpapi(token.encode("ascii"), True)).decode("ascii"),
"nutzer": nutzer,
}, ensure_ascii=False, indent=2), encoding="utf-8")
os.replace(zwischen, KONTO_DATEI)
with _sperre:
_sitzung, _geladen = {"token": token, "nutzer": nutzer}, True
def _vergessen():
global _sitzung, _geladen
with _sperre:
_sitzung, _geladen = None, True
try:
KONTO_DATEI.unlink()
except OSError:
pass
# -- Aufrufe -------------------------------------------------------------------
def anfrage(aktion, token=None, **felder):
"""Ruft eine Aktion der Schnittstelle auf. Gibt die Antwort zurueck oder wirft ServerFehler."""
_adresse_pruefen()
kopf = {"Content-Type": "application/json", "User-Agent": "SquadManager"}
if token:
kopf["X-SM-Token"] = token
koerper = json.dumps({"aktion": aktion, **felder}, ensure_ascii=False).encode("utf-8")
anfrage_ = urllib.request.Request(SERVER + "/api/", data=koerper, headers=kopf, method="POST")
http = 200
try:
with urllib.request.urlopen(anfrage_, timeout=ZEITLIMIT) as antwort:
text = antwort.read()
except urllib.error.HTTPError as fehler:
http, text = fehler.code, fehler.read()
except (urllib.error.URLError, OSError) as fehler:
raise ServerFehler("offline", "Keine Verbindung zum Server. Besteht eine Internetverbindung?") from fehler
try:
daten = json.loads(text.decode("utf-8"))
except ValueError:
raise ServerFehler("serverfehler", f"Der Server antwortet nicht wie erwartet (HTTP {http}).", http) from None
if not isinstance(daten, dict) or daten.get("ok") is not True:
daten = daten if isinstance(daten, dict) else {}
code = daten.get("fehler", "serverfehler")
if code == "nicht_angemeldet" and token:
_vergessen()
raise ServerFehler(code, daten.get("meldung", "Unbekannter Fehler vom Server."), http, daten)
return daten
def aufrufen(aktion, **felder):
"""Wie anfrage(), mit dem Token der gespeicherten Anmeldung."""
stand = sitzung()
if not stand:
raise ServerFehler("nicht_angemeldet", "Bitte melde dich an.")
return anfrage(aktion, token=stand["token"], **felder)
def angemeldet():
return sitzung() is not None
def nutzer():
stand = sitzung()
return stand["nutzer"] if stand else None
def gesichert():
"""True, wenn das Konto E-Mail und Passwort hat - sonst haengt es am Schluessel dieses PCs."""
stand = nutzer()
return bool(stand and stand.get("gesichert", True))
def mitmachen(spielername):
"""Mitmachen ohne Konto: Der Server legt einen Nutzer an, das Token ist der Schluessel des PCs."""
antwort = anfrage("mitmachen", spielername=spielername, geraet=socket.gethostname()[:100])
_merken(antwort["token"], antwort["nutzer"])
return antwort["nutzer"]
def konto_sichern(email, passwort):
antwort = aufrufen("konto_sichern", email=email, passwort=passwort)
_merken(sitzung()["token"], antwort["nutzer"])
return antwort["nutzer"]
def registrieren(benutzername, email, passwort):
return anfrage("registrieren", benutzername=benutzername, email=email, passwort=passwort)
def anmelden(login, passwort):
antwort = anfrage("anmelden", login=login, passwort=passwort, geraet=socket.gethostname()[:100])
_merken(antwort["token"], antwort["nutzer"])
return antwort["nutzer"]
def abmelden():
stand = sitzung()
try:
if stand:
anfrage("abmelden", token=stand["token"])
except ServerFehler:
pass
finally:
_vergessen()
def pruefen():
"""Fragt, ob die gespeicherte Anmeldung noch gilt. Aktualisiert die Nutzerdaten."""
stand = sitzung()
if not stand:
return None
antwort = anfrage("ich", token=stand["token"])
if antwort["nutzer"] != stand["nutzer"]:
_merken(stand["token"], antwort["nutzer"])
return antwort["nutzer"]
def bestaetigung_erneut(email):
return anfrage("bestaetigung_erneut", email=email)
def passwort_vergessen(email):
return anfrage("passwort_vergessen", email=email)
def bild(charakter_id):
"""Portraet eines Charakters als PNG-Bytes oder None."""
_adresse_pruefen()
stand = sitzung()
if not stand:
raise ServerFehler("nicht_angemeldet", "Bitte melde dich an.")
anfrage_ = urllib.request.Request(f"{SERVER}/api/bild.php?id={int(charakter_id)}",
headers={"X-SM-Token": stand["token"], "User-Agent": "SquadManager"})
try:
with urllib.request.urlopen(anfrage_, timeout=ZEITLIMIT) as antwort:
return antwort.read(16 * 1024 * 1024)
except urllib.error.HTTPError as fehler:
if fehler.code == 404:
return None
raise ServerFehler("serverfehler", f"Porträt nicht abrufbar (HTTP {fehler.code}).", fehler.code) from None
except (urllib.error.URLError, OSError) as fehler:
raise ServerFehler("offline", "Keine Verbindung zum Server.") from fehler
def webseite(pfad):
return SERVER + pfad