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>
249 lines
8.6 KiB
Python
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
|