""" 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