PHP 8 ohne Framework unter server/: oeffentliche Einstiege fuer sva.tyrveil.com (Schnittstelle, Konto-Links, Verwaltung, Einrichtung) und die Logik in sva-privat neben dem Dokumentenstamm. - Konten mit E-Mail-Bestaetigung, Anmeldung per Token, Passwort vergessen, Konto loeschen - Akten auf dem Server mit serververgebener Aktennummer und Versionspruefung; Portraets werden neu als PNG gespeichert - Squads mit Einladungen, Fuehrung uebergeben, Aufloesen - Verwaltung fuer info@tyrveil.com: Nutzer, Charaktere, Squads - Bremsen gegen Durchprobieren, Token nur als Hash, CSRF-Schutz werkzeuge/server_test.py prueft alles lokal mit SQLite (91 Faelle). Der Release-Bau legt dist/server und dist/sva-privat an, ohne config.php. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
433 lines
25 KiB
Python
433 lines
25 KiB
Python
"""
|
|
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 io
|
|
import json
|
|
import quopri
|
|
import re
|
|
import shutil
|
|
import socket
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
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 ""))
|
|
|
|
|
|
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"""<?php
|
|
return [
|
|
'datenbank' => ['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")
|
|
self.prozess = subprocess.Popen(
|
|
["php", "-S", f"127.0.0.1:{self.port}", "-t", str(self.ordner / "sva.tyrveil.com")],
|
|
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
|
for _ in range(50):
|
|
try:
|
|
socket.create_connection(("127.0.0.1", self.port), timeout=0.2).close()
|
|
break
|
|
except OSError:
|
|
time.sleep(0.1)
|
|
|
|
def beenden(self):
|
|
self.prozess.terminate()
|
|
self.prozess.wait(timeout=10)
|
|
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"<?php echo 1; ?>").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("<tr>")
|
|
for zeile in zeilen:
|
|
if email in zeile:
|
|
treffer = re.search(r'name="id" value="(\d+)"', zeile)
|
|
if treffer:
|
|
return treffer.group(1)
|
|
return "0"
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|