Abgleich der Akten mit dem Server (ohne Oberflaeche)

- konto.py: Aufrufe der Schnittstelle, Anmeldung; das Token liegt per
  DPAPI an das Windows-Konto gebunden in konto.json
- abgleich.py: gleicht lokale Akten und Server ab. server.json neben
  jeder Akte haelt den Stand des letzten Abgleichs (Pruefwert des Inhalts
  statt Zeitstempel, der nur sekundengenau ist). Konflikte sichern die
  Serverfassung als konflikt-<Zeit>.json; auf dem Server geloeschte Akten
  wandern lokal in den Papierkorb
- hintergrund.py: Netzwerkarbeit im Thread, Ergebnis im tkinter-Hauptthread
- akte_modell.speichern(zeit_setzen=False) fuer uebernommene Serverdaten
- Server liefert portraet_kennung, damit ein zweiter Rechner neue Bilder erkennt
- Tests: werkzeuge/abgleich_test.py mit zwei simulierten Rechnern (34
  Faelle); der Testserver nutzt php-cgi statt "php -S", das unter Windows
  nach vielen Verbindungen haengen bleibt

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
danny 2026-09-13 19:50:57 +02:00
parent fb318980a1
commit 0c7aae5b93
7 changed files with 918 additions and 14 deletions

230
konto.py Normal file
View file

@ -0,0 +1,230 @@
"""
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 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