""" Gesamttest des Servers (server/) auf dem eigenen Rechner. Kopiert server/ in einen temporaeren Ordner mit derselben Aufteilung wie auf Plesk (sva.tyrveil.com neben sva-privat), schreibt eine Test-config.php mit SQLite und Mails als Dateien, startet den PHP-Entwicklungsserver und spielt alle Ablaeufe durch. Beruehrt weder den echten Server noch die echte Datenbank. Aufruf: .venv\\Scripts\\python.exe werkzeuge\\server_test.py Braucht: php (8.1+) mit pdo_sqlite, gd, mbstring im Suchpfad. """ import base64 import http.cookiejar import http.server import io import json import os import quopri import re import shutil import socket import subprocess import sys import tempfile import threading import time import urllib.error import urllib.parse import urllib.request from pathlib import Path from PIL import Image WURZEL = Path(__file__).resolve().parent.parent SCHLUESSEL = "test-einrichtung-0123456789abcdef" ergebnisse = {"ok": 0, "fehl": 0} def pruefe(name, bedingung, info=""): if bedingung: ergebnisse["ok"] += 1 print(f" OK {name}") else: ergebnisse["fehl"] += 1 print(f" FEHL {name}" + (f" [{info}]" if info else "")) class _CgiServer(http.server.ThreadingHTTPServer): daemon_threads = True class _CgiAnfrage(http.server.BaseHTTPRequestHandler): """Liefert statische Dateien selbst und reicht .php an php-cgi weiter.""" def log_message(self, format, *args): with open(self.server.protokoll, "a", encoding="utf-8") as datei: datei.write(time.strftime("[%H:%M:%S] ") + (format % args) + "\n") def do_GET(self): self._behandeln() def do_POST(self): self._behandeln() def _antwort(self, status, kopf, inhalt): self.send_response(status) for name, wert in kopf: self.send_header(name, wert) self.send_header("Content-Length", str(len(inhalt))) self.send_header("Connection", "close") self.end_headers() self.wfile.write(inhalt) def _behandeln(self): wurzel = self.server.dokumentenstamm pfad, _, abfrage = self.path.partition("?") ziel = (wurzel / urllib.parse.unquote(pfad).lstrip("/")).resolve() if wurzel not in ziel.parents and ziel != wurzel: return self._antwort(403, [], b"") if ziel.is_dir(): ziel = ziel / "index.php" if not ziel.is_file(): return self._antwort(404, [("Content-Type", "text/plain")], b"File not found.") laenge = int(self.headers.get("Content-Length") or 0) koerper = self.rfile.read(laenge) if laenge else b"" if ziel.suffix != ".php": art = {".png": "image/png", ".html": "text/html", ".json": "application/json"}.get(ziel.suffix, "application/octet-stream") return self._antwort(200, [("Content-Type", art)], ziel.read_bytes()) umgebung = {k: v for k, v in os.environ.items() if k.upper() in ("SYSTEMROOT", "PATH", "TEMP", "TMP", "WINDIR")} umgebung.update({ "REDIRECT_STATUS": "200", "GATEWAY_INTERFACE": "CGI/1.1", "SERVER_PROTOCOL": "HTTP/1.1", "SCRIPT_FILENAME": str(ziel), "SCRIPT_NAME": "/" + ziel.relative_to(wurzel).as_posix(), "REQUEST_METHOD": self.command, "QUERY_STRING": abfrage, "REQUEST_URI": self.path, "CONTENT_LENGTH": str(laenge), "CONTENT_TYPE": self.headers.get("Content-Type", ""), "SERVER_NAME": "127.0.0.1", "SERVER_PORT": str(self.server.server_port), "REMOTE_ADDR": self.client_address[0], "DOCUMENT_ROOT": str(wurzel), }) for name, wert in self.headers.items(): if name.lower() not in ("content-length", "content-type"): umgebung["HTTP_" + name.upper().replace("-", "_")] = wert lauf = subprocess.run([self.server.php_cgi], input=koerper, capture_output=True, env=umgebung, timeout=60) if lauf.stderr: self.log_message("php-cgi: %s", lauf.stderr.decode("utf-8", "replace")[:500]) kopftext, _, inhalt = lauf.stdout.partition(b"\r\n\r\n") status, kopf = 200, [] for zeile in kopftext.decode("latin-1").split("\r\n"): name, _, wert = zeile.partition(":") if name.lower() == "status": status = int(wert.strip().split()[0]) elif name: kopf.append((name, wert.strip())) if status == 200 and any(n.lower() == "location" for n, _ in kopf): status = 302 self._antwort(status, kopf, inhalt) def freier_port(): with socket.socket() as s: s.bind(("127.0.0.1", 0)) return s.getsockname()[1] class Server: def __init__(self): self.ordner = Path(tempfile.mkdtemp(prefix="sm_servertest_")) shutil.copytree(WURZEL / "server", self.ordner, dirs_exist_ok=True) (self.ordner / "sva-privat" / "config.php").unlink(missing_ok=True) shutil.rmtree(self.ordner / "sva-privat" / "daten", ignore_errors=True) shutil.copy2(WURZEL / "icon.png", self.ordner / "sva.tyrveil.com" / "icon.png") self.port = freier_port() self.basis = f"http://127.0.0.1:{self.port}" privat = self.ordner / "sva-privat" dsn = "sqlite:" + (privat / "test.sqlite").as_posix() (privat / "config.php").write_text(f""" ['dsn' => '{dsn}', 'benutzer' => '', 'passwort' => ''], 'basis_url' => '{self.basis}', 'rechtliches_url' => 'https://tyrveil.com/rechtliches#impressum', 'admin_email' => 'info@tyrveil.com', 'mail' => ['art' => 'datei', 'absender' => 'info@tyrveil.com', 'absender_name' => 'Squad Manager'], 'einrichtungs_schluessel' => '{SCHLUESSEL}', 'daten_ordner' => __DIR__ . '/daten', 'fehler_anzeigen' => false, ]; """, encoding="utf-8") # Nicht "php -S": Der Entwicklungsserver nimmt unter Windows nach # einigen hundert schnellen Verbindungen keine mehr an. Stattdessen # startet ein Python-Server fuer jede Anfrage ein eigenes php-cgi - # naeher an Plesk, wo PHP ebenfalls in eigenen Prozessen laeuft. self.protokoll = self.ordner / "php-server.log" self.webserver = _CgiServer(("127.0.0.1", self.port), _CgiAnfrage) self.webserver.dokumentenstamm = (self.ordner / "sva.tyrveil.com").resolve() self.webserver.protokoll = self.protokoll self.webserver.php_cgi = str(Path(shutil.which("php")).with_name("php-cgi.exe")) threading.Thread(target=self.webserver.serve_forever, daemon=True).start() def laeuft(self): return self.webserver is not None def php_protokoll(self, zeilen=15): text = self.protokoll.read_text(encoding="utf-8", errors="replace") if self.protokoll.exists() else "" return "\n".join(text.splitlines()[-zeilen:]) def beenden(self): self.webserver.shutdown() self.webserver.server_close() self.webserver = None shutil.rmtree(self.ordner, ignore_errors=True) @property def daten(self): return self.ordner / "sva-privat" / "daten" def letzte_mail(self, an): mails = sorted((self.daten / "mails").glob("*.eml"), key=lambda p: p.stat().st_mtime_ns) for pfad in reversed(mails): roh = pfad.read_bytes() kopf, _, inhalt = roh.partition(b"\r\n\r\n") if f"To: {an}".encode() in kopf: return quopri.decodestring(inhalt).decode("utf-8") return "" def link_aus_mail(self, an): treffer = re.search(r"http://127\.0\.0\.1:\d+/\S+", self.letzte_mail(an)) return treffer.group(0) if treffer else "" # -- HTTP --------------------------------------------------------------- def api(self, aktion, token=None, **felder): anfrage = urllib.request.Request( self.basis + "/api/", data=json.dumps({"aktion": aktion, **felder}).encode(), headers={"Content-Type": "application/json", **({"X-SM-Token": token} if token else {})}, method="POST") try: with urllib.request.urlopen(anfrage, timeout=30) as antwort: return antwort.status, json.loads(antwort.read()) except urllib.error.HTTPError as fehler: text = fehler.read() try: return fehler.code, json.loads(text) except ValueError: return fehler.code, {"roh": text[:300]} def roh(self, pfad, daten=None, token=None, oeffner=None, methode=None): kodiert = urllib.parse.urlencode(daten).encode() if daten is not None else None anfrage = urllib.request.Request(self.basis + pfad, data=kodiert, method=methode, headers={"X-SM-Token": token} if token else {}) try: with (oeffner or urllib.request.build_opener()).open(anfrage, timeout=30) as antwort: return antwort.status, antwort.read(), dict(antwort.headers) except urllib.error.HTTPError as fehler: return fehler.code, fehler.read(), dict(fehler.headers) def akte(lokale_id, callsign, nachname, rang="", status="aktiv"): return {"schema": 1, "id": lokale_id, "aktennummer": "SM-2026-0001", "personalien": {"vorname": "Test", "nachname": nachname, "callsign": callsign}, "dienst": {"fraktion": "Bundeswehr", "teilstreitkraft": "Heer", "rang": rang, "verwendung": "Medic", "status": status}, "beschreibung": "", "auszeichnungen": [], "einsaetze": [], "vermerke": ""} def png_base64(breite=900, hoehe=1200): puffer = io.BytesIO() Image.new("RGB", (breite, hoehe), (80, 90, 60)).save(puffer, "JPEG") return base64.b64encode(puffer.getvalue()).decode() def main(): s = Server() try: ablauf(s) finally: log = s.daten / "fehler.log" inhalt = log.read_text(encoding="utf-8") if log.exists() else "" pruefe("fehler.log des Servers leer", not inhalt.strip(), inhalt[-600:]) s.beenden() print(f"\nERGEBNIS: {ergebnisse['ok']} bestanden, {ergebnisse['fehl']} fehlgeschlagen") sys.exit(1 if ergebnisse["fehl"] else 0) def ablauf(s): print("Einrichtung") code, html, kopf = s.roh("/einrichten.php") pruefe("Formular erreichbar", code == 200 and b"Einrichtungsschl" in html, code) pruefe("Sicherheitskopf Referrer-Policy", kopf.get("Referrer-Policy") == "no-referrer", kopf) code, html, _ = s.roh("/einrichten.php", {"schluessel": "falsch"}) pruefe("falscher Schlüssel abgewiesen", "stimmt nicht" in html.decode()) code, html, _ = s.roh("/einrichten.php", {"schluessel": SCHLUESSEL}) text = html.decode() pruefe("Tabellen angelegt", "7 Tabellen vorhanden" in text, text[-500:]) admin_link = s.link_aus_mail("info@tyrveil.com") pruefe("Passwort-Mail an info@tyrveil.com", "/konto/passwort.php?t=" in admin_link, admin_link) code, html, _ = s.roh("/einrichten.php", {"schluessel": SCHLUESSEL}) pruefe("zweiter Aufruf schadet nicht", "vorhanden" in html.decode()) erster_link, admin_link = admin_link, s.link_aus_mail("info@tyrveil.com") pruefe("zweiter Aufruf schickt neuen Link", admin_link and admin_link != erster_link) code, html, _ = s.roh(urllib.parse.urlparse(erster_link).path + "?" + urllib.parse.urlparse(erster_link).query) pruefe("erster Link damit ungültig", "ungültig" in html.decode()) print("Schnittstelle allgemein") code, antwort = s.api("status") pruefe("status", code == 200 and antwort.get("api") == 1, antwort) code, _, _ = s.roh("/api/", methode="GET") pruefe("GET wird abgewiesen (405)", code == 405, code) code, antwort = s.api("charaktere_alle") pruefe("ohne Token: nicht_angemeldet (401)", code == 401 and antwort["fehler"] == "nicht_angemeldet", antwort) code, antwort = s.api("gibtsnicht", token="0" * 64) pruefe("falsches Token: 401", code == 401, antwort) print("Registrierung") for name, email, pw, erwartet in ( ("al", "al@example.org", "langespasswort1", "benutzername_ungueltig"), ("alice", "keine-mail", "langespasswort1", "email_ungueltig"), ("alice", "alice@example.org", "kurz", "passwort_zu_schwach")): code, antwort = s.api("registrieren", benutzername=name, email=email, passwort=pw) pruefe(f"abgewiesen: {erwartet}", antwort.get("fehler") == erwartet, antwort) code, antwort = s.api("registrieren", benutzername="Alice", email="Alice@Example.org", passwort="alicepasswort1") pruefe("Alice registriert", code == 200 and antwort["ok"], antwort) code, antwort = s.api("registrieren", benutzername="bob", email="bob@example.org", passwort="bobpasswort12") pruefe("Bob registriert", code == 200 and antwort["ok"], antwort) code, antwort = s.api("registrieren", benutzername="ALICE", email="neu@example.org", passwort="alicepasswort1") pruefe("Benutzername doppelt (Groß/klein egal)", antwort.get("fehler") == "benutzername_vergeben", antwort) code, antwort = s.api("anmelden", login="alice", passwort="alicepasswort1") pruefe("vor Bestätigung: nicht_bestaetigt", antwort.get("fehler") == "nicht_bestaetigt", antwort) for wer in ("alice@example.org", "bob@example.org"): link = s.link_aus_mail(wer) code, html, _ = s.roh(urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query) pruefe(f"Bestätigungslink {wer.split('@')[0]}", code == 200 and "bestätigt" in html.decode(), link) code, html, _ = s.roh(urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query) pruefe("Link nur einmal gültig", "ungültig" in html.decode()) print("Anmeldung") code, antwort = s.api("anmelden", login="alice", passwort="falsch-falsch") pruefe("falsches Passwort", antwort.get("fehler") == "anmeldung_falsch", antwort) code, antwort = s.api("anmelden", login="ALICE@example.org", passwort="alicepasswort1", geraet="Test-PC") alice = antwort.get("token") pruefe("Alice per E-Mail angemeldet", code == 200 and alice and antwort["nutzer"]["benutzername"] == "Alice", antwort) code, antwort = s.api("anmelden", login="bob", passwort="bobpasswort12") bob = antwort.get("token") pruefe("Bob angemeldet", bool(bob), antwort) code, antwort = s.api("ich", token=alice) pruefe("ich", antwort.get("nutzer", {}).get("email") == "alice@example.org", antwort) print("Charaktere") ids = {n: f"{i:032x}" for i, n in enumerate(("nordlicht", "rook", "frost"), start=11)} code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=akte(ids["nordlicht"], "Nordlicht", "Brandt", "Oberfeldwebel")) nordlicht = antwort.get("charakter", {}) pruefe("Akte gespeichert, Server vergibt Nummer", code == 200 and re.fullmatch(r"SM-\d{4}-\d{4}", nordlicht.get("aktennummer") or "") and nordlicht["daten"]["aktennummer"] == nordlicht["aktennummer"], antwort) code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["frost"], daten=akte(ids["frost"], "Frost", "Sigurdsson")) frost = antwort.get("charakter", {}) code, antwort = s.api("charakter_speichern", token=bob, lokale_id=ids["rook"], daten=akte(ids["rook"], "Rook", "Hutchins", status="gefallen")) rook = antwort.get("charakter", {}) nummern = {nordlicht.get("aktennummer"), frost.get("aktennummer"), rook.get("aktennummer")} pruefe("Aktennummern eindeutig", len(nummern) == 3 and None not in nummern, nummern) geaendert = akte(ids["nordlicht"], "Nordlicht", "Brandt", "Hauptfeldwebel") code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert, basis_version=1) pruefe("Änderung mit passender Version", antwort.get("charakter", {}).get("version") == 2, antwort) code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert, basis_version=1) pruefe("veraltete Version: konflikt (409) mit Serverstand", code == 409 and antwort.get("charakter", {}).get("version") == 2, antwort) code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert, basis_version=1, erzwingen=True) pruefe("erzwingen überschreibt", antwort.get("charakter", {}).get("version") == 3, antwort) code, antwort = s.api("charakter_speichern", token=alice, lokale_id="kaputt", daten={}) pruefe("ungültige Akten-ID", antwort.get("fehler") == "lokale_id_ungueltig", antwort) code, antwort = s.api("portraet_hochladen", token=alice, lokale_id=ids["nordlicht"], bild=png_base64()) pruefe("Porträt hochgeladen", antwort.get("charakter", {}).get("portraet") is True, antwort) code, bild, kopf = s.roh(f"/api/bild.php?id={nordlicht['id']}", token=bob) groesse = Image.open(io.BytesIO(bild)).size if code == 200 else None pruefe("Porträt für andere abrufbar, neu als PNG ≤ 512", code == 200 and kopf.get("Content-Type") == "image/png" and max(groesse) == 512, (code, groesse)) code, _, _ = s.roh(f"/api/bild.php?id={nordlicht['id']}") pruefe("Porträt ohne Token: 401", code == 401, code) code, antwort = s.api("portraet_hochladen", token=alice, lokale_id=ids["nordlicht"], bild=base64.b64encode(b"").decode()) pruefe("keine Bilddatei: abgewiesen", antwort.get("fehler") == "bild_ungueltig", antwort) code, antwort = s.api("portraet_hochladen", token=bob, lokale_id=ids["nordlicht"], bild=png_base64(10, 10)) pruefe("fremde Akte: nicht gefunden", antwort.get("fehler") == "charakter_nicht_gefunden", antwort) code, antwort = s.api("charaktere_alle", token=bob) liste = antwort.get("charaktere", []) pruefe("Bob sieht alle 3 Charaktere mit Status", len(liste) == 3 and {c["callsign"]: c["status"] for c in liste}.get("Rook") == "gefallen", liste) pruefe("'eigener' richtig gesetzt", [c["callsign"] for c in liste if c["eigener"]] == ["Rook"], liste) code, antwort = s.api("charaktere_alle", token=bob, suche="nord") pruefe("Suche", [c["callsign"] for c in antwort.get("charaktere", [])] == ["Nordlicht"], antwort) code, antwort = s.api("charaktere_alle", token=bob, suche="100%_") pruefe("Suche mit Sonderzeichen", code == 200 and antwort.get("charaktere") == [], antwort) code, antwort = s.api("charakter_ansehen", token=bob, id=nordlicht["id"]) pruefe("fremde Akte ansehen", antwort.get("charakter", {}).get("daten", {}).get("dienst", {}).get("rang") == "Hauptfeldwebel", antwort) print("Squads") code, antwort = s.api("squad_gruenden", token=alice, charakter_id=nordlicht["id"], name=" Nordwind ") squad = antwort.get("squad", {}) pruefe("Squad gegründet", squad.get("name") == "Nordwind" and squad.get("fuehrer_id") == nordlicht["id"], antwort) code, antwort = s.api("squad_gruenden", token=bob, charakter_id=rook["id"], name="nordwind") pruefe("Name doppelt", antwort.get("fehler") == "name_vergeben", antwort) code, antwort = s.api("squad_gruenden", token=bob, charakter_id=nordlicht["id"], name="Fremd") pruefe("fremder Charakter kann nicht gründen", antwort.get("fehler") == "charakter_nicht_gefunden", antwort) code, antwort = s.api("squad_einladen", token=bob, squad_id=squad["id"], charakter_id=rook["id"]) pruefe("Nicht-Führer kann nicht einladen", antwort.get("fehler") == "kein_fuehrer", antwort) code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=rook["id"]) einladung = antwort.get("einladung", {}) pruefe("Alice lädt Rook ein", einladung.get("status") == "offen", antwort) code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=rook["id"]) pruefe("doppelte Einladung", antwort.get("fehler") == "schon_eingeladen", antwort) code, antwort = s.api("einladungen", token=bob) pruefe("Bob sieht Einladung im Eingang", [e["squad"]["name"] for e in antwort.get("eingang", [])] == ["Nordwind"], antwort) code, antwort = s.api("einladungen", token=alice) pruefe("Alice sieht sie im Ausgang", len(antwort.get("ausgang", [])) == 1, antwort) code, antwort = s.api("einladung_beantworten", token=alice, einladung_id=einladung["id"], annehmen=True) pruefe("Alice kann Bobs Einladung nicht annehmen", antwort.get("fehler") == "charakter_nicht_gefunden", antwort) code, antwort = s.api("einladung_beantworten", token=bob, einladung_id=einladung["id"], annehmen=True) pruefe("Bob nimmt an", code == 200 and antwort["ok"], antwort) code, antwort = s.api("einladung_beantworten", token=bob, einladung_id=einladung["id"], annehmen=True) pruefe("zweimal annehmen geht nicht", antwort.get("fehler") == "einladung_nicht_offen", antwort) code, antwort = s.api("squad_gruenden", token=bob, charakter_id=rook["id"], name="Zweites") pruefe("im Squad kein zweites gründen", antwort.get("fehler") == "bereits_im_squad", antwort) code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=frost["id"]) frost_einladung = antwort.get("einladung", {}) code, antwort = s.api("einladung_zurueckziehen", token=alice, einladung_id=frost_einladung.get("id")) pruefe("Einladung zurückgezogen", code == 200, antwort) code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=frost["id"]) code, antwort = s.api("einladung_beantworten", token=alice, einladung_id=antwort["einladung"]["id"], annehmen=False) pruefe("Einladung abgelehnt", code == 200, antwort) code, antwort = s.api("squad_ansehen", token=bob, squad_id=squad["id"]) pruefe("Squad hat 2 Mitglieder", [m["callsign"] for m in antwort.get("squad", {}).get("mitglieder", [])] == ["Nordlicht", "Rook"], antwort) code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"]) pruefe("Führer mit Mitgliedern muss übergeben", antwort.get("fehler") == "fuehrer_muss_uebergeben", antwort) code, antwort = s.api("squad_fuehrung_uebergeben", token=alice, squad_id=squad["id"], charakter_id=rook["id"]) pruefe("Führung an Rook übergeben", code == 200, antwort) code, antwort = s.api("squad_entfernen", token=alice, squad_id=squad["id"], charakter_id=rook["id"]) pruefe("Ex-Führer kann nicht mehr entfernen", antwort.get("fehler") == "kein_fuehrer", antwort) code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"]) pruefe("Nordlicht verlässt das Squad", code == 200, antwort) code, antwort = s.api("squad_einladen", token=bob, squad_id=squad["id"], charakter_id=nordlicht["id"]) s.api("einladung_beantworten", token=alice, einladung_id=antwort["einladung"]["id"], annehmen=True) code, antwort = s.api("charakter_loeschen", token=bob, lokale_id=ids["rook"]) pruefe("Führer gelöscht", code == 200, antwort) code, antwort = s.api("squad_ansehen", token=alice, squad_id=squad["id"]) pruefe("dienstältestes Mitglied übernimmt", antwort.get("squad", {}).get("fuehrer_id") == nordlicht["id"], antwort) code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"]) code, antwort = s.api("squads", token=alice) pruefe("letztes Mitglied geht: Squad aufgelöst", antwort.get("squads") == [], antwort) print("Passwort vergessen") code, antwort = s.api("passwort_vergessen", email="gibtsnicht@example.org") pruefe("unbekannte Adresse: gleiche Antwort", code == 200 and antwort["ok"], antwort) code, antwort = s.api("passwort_vergessen", email="alice@example.org") link = s.link_aus_mail("alice@example.org") pfad = urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query code, html, _ = s.roh(pfad) pruefe("Formular per GET, Link noch nicht verbraucht", code == 200 and "Neues Passwort" in html.decode(), link) token = urllib.parse.parse_qs(urllib.parse.urlparse(link).query)["t"][0] code, html, _ = s.roh("/konto/passwort.php", {"t": token, "passwort": "neuespasswort1", "wiederholung": "anders"}) pruefe("Wiederholung falsch", "stimmen nicht" in html.decode()) code, html, _ = s.roh("/konto/passwort.php", {"t": token, "passwort": "neuespasswort1", "wiederholung": "neuespasswort1"}) pruefe("neues Passwort gespeichert", "Passwort gespeichert" in html.decode()) code, antwort = s.api("ich", token=alice) pruefe("alte Sitzung abgemeldet", code == 401, antwort) code, antwort = s.api("anmelden", login="alice", passwort="neuespasswort1") alice = antwort.get("token") pruefe("Anmeldung mit neuem Passwort", bool(alice), antwort) print("Verwaltung") jar = http.cookiejar.CookieJar() oeffner = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar)) def csrf(html): treffer = re.search(rb'name="csrf" value="([0-9a-f]+)"', html) return treffer.group(1).decode() if treffer else "" admin_token = urllib.parse.parse_qs(urllib.parse.urlparse(admin_link).query)["t"][0] code, html, _ = s.roh("/konto/passwort.php", {"t": admin_token, "passwort": "adminpasswort99", "wiederholung": "adminpasswort99"}) pruefe("Admin-Passwort über Einrichtungslink gesetzt", "Zur Verwaltung" in html.decode()) code, html, _ = s.roh("/verwaltung/", oeffner=oeffner) pruefe("Verwaltung fordert Anmeldung", "Anmelden" in html.decode()) code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "info@tyrveil.com", "passwort": "falsch", "csrf": csrf(html)}, oeffner=oeffner) pruefe("falsches Admin-Passwort", "stimmt nicht" in html.decode()) code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "alice@example.org", "passwort": "neuespasswort1", "csrf": csrf(html)}, oeffner=oeffner) pruefe("normaler Nutzer kommt nicht in die Verwaltung", "stimmt nicht" in html.decode()) code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "info@tyrveil.com", "passwort": "adminpasswort99", "csrf": csrf(html)}, oeffner=oeffner) pruefe("Admin angemeldet, Übersicht", code == 200 and "Offene Einladungen" in html.decode(), html[-300:]) for seite, erwartet in (("nutzer", "alice@example.org"), ("charaktere", "Nordlicht"), ("squads", "Squads"), (f"charakter&id={nordlicht['id']}", "ROHDATEN")): code, html, _ = s.roh(f"/verwaltung/?seite={seite}", oeffner=oeffner) pruefe(f"Seite {seite.split('&')[0]}", code == 200 and erwartet in html.decode(), code) code, bild, kopf = s.roh(f"/verwaltung/?seite=bild&id={nordlicht['id']}", oeffner=oeffner) pruefe("Porträt in der Verwaltung", code == 200 and kopf.get("Content-Type") == "image/png", code) code, html, _ = s.roh("/verwaltung/?seite=nutzer", oeffner=oeffner) bob_id = s_nutzer_id(html, "bob@example.org") code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_sperren", "id": bob_id}, oeffner=oeffner) pruefe("ohne CSRF-Token abgewiesen", "abgelaufen" in html.decode()) code, html, _ = s.roh("/verwaltung/?seite=nutzer", oeffner=oeffner) code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_sperren", "id": bob_id, "csrf": csrf(html)}, oeffner=oeffner) pruefe("Bob gesperrt", "gesperrt und abgemeldet" in html.decode()) code, antwort = s.api("ich", token=bob) pruefe("Bobs Sitzung ungültig", code == 401, antwort) code, antwort = s.api("anmelden", login="bob", passwort="bobpasswort12") pruefe("Bob kann sich nicht anmelden", antwort.get("fehler") == "gesperrt", antwort) code, html, _ = s.roh(f"/verwaltung/?seite=bestaetigen&aktion=nutzer_loeschen&id={bob_id}", oeffner=oeffner) pruefe("Löschen zeigt Bestätigungsseite", "Ja, ausführen" in html.decode() and "bob" in html.decode()) code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_loeschen", "id": bob_id, "csrf": csrf(html)}, oeffner=oeffner) pruefe("Bob gelöscht", "gelöscht" in html.decode() and "bob@example.org" not in html.decode()) print("Konto und Bremse") code, antwort = s.api("konto_loeschen", token=alice, passwort="falsch") pruefe("Konto löschen braucht Passwort", antwort.get("fehler") == "anmeldung_falsch", antwort) code, antwort = s.api("konto_loeschen", token=alice, passwort="neuespasswort1") pruefe("Alice löscht ihr Konto", code == 200, antwort) portraets = list((s.daten / "portraets").glob("*.png")) pruefe("Porträtdateien mitgelöscht", portraets == [], portraets) antworten = [s.api("anmelden", login="niemand", passwort="falsch-falsch")[1].get("fehler") for _ in range(11)] pruefe("nach 10 Fehlversuchen: zu_viele_versuche", antworten[-1] == "zu_viele_versuche", antworten) def s_nutzer_id(html, email): zeilen = html.decode().split("