diff --git a/.gitignore b/.gitignore
index b90922b..b9827d0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,7 @@ __pycache__/
# Editor
.idea/
.vscode/
+
+# Server: Zugangsdaten und Nutzerdaten nie ins Repository
+server/sva-privat/config.php
+server/sva-privat/daten/
diff --git a/PROJEKT-UEBERGABE.md b/PROJEKT-UEBERGABE.md
index 7bb5ffb..836ab1c 100644
--- a/PROJEKT-UEBERGABE.md
+++ b/PROJEKT-UEBERGABE.md
@@ -51,6 +51,7 @@ akte_modell.py Akte: Datenmodell und Speicherung, ohne tkinter
akte_vorlagen.py Akte: Fraktionen, Dienstgrade, Verwendungen
akte_karte.py Akte: PNG-Karte zum Teilen, Zwischenablage
update_helfer.py spielt Updates ein, bei Bedarf mit Adminrechten
+server/ PHP-Server für Konten und Squads, siehe Abschnitt 4
start.pyw Startskript ohne Konsolenfenster
make_icon.py erzeugt icon.ico aus icon.png
icon.png / icon.ico Programmsymbol (vom Nutzer geliefert)
@@ -281,6 +282,56 @@ auf.
---
+### Server für Konten und Squads (ab 1.6.0)
+
+PHP 8 ohne Framework in `server/`, getrennt nach Sichtbarkeit:
+
+```
+server/sva.tyrveil.com/ → /sva.tyrveil.com (Dokumentenstamm, öffentlich)
+ api/index.php Schnittstelle fürs Programm (POST, JSON)
+ api/bild.php Porträts, nur mit Token
+ konto/ Links aus Mails: bestätigen, Passwort, vergessen
+ verwaltung/ Admin-Oberfläche
+ einrichten.php Ersteinrichtung, nur mit Schlüssel aus config.php
+server/sva-privat/ → /sva-privat, NEBEN dem Dokumentenstamm
+ app/ gesamte Logik
+ config.beispiel.php Vorlage; config.php liegt nur auf dem Server
+ daten/ Porträts, Fehlerlog (nicht im Repository)
+```
+
+Plesk: PHP 8.5, Dokumentenstamm `/sva.tyrveil.com`, Datenbank und Benutzer
+`214729_sva` (MySQL/MariaDB). Das Datenbank-Passwort steht nur in
+`sva-privat/config.php` auf dem Server — nie ins Repository, nie in den
+Chat. Mails verschickt `mail()` über den Plesk-Mailserver mit Absender
+`info@tyrveil.com`, ohne Postfach-Passwort. Verwaltungszugang:
+`info@tyrveil.com`, Passwort über den Link aus `einrichten.php`.
+
+**Schnittstelle:** `POST /api/` mit `{"aktion": …}`, Token im Kopf
+`X-SM-Token` (nicht `Authorization`, das verschlucken Plesk-Setups gern).
+Antwort `{"ok": true, …}` oder `{"ok": false, "fehler": code, "meldung":
+Text}`. Die Aktionen stehen gesammelt in `app/api.php`.
+
+**Regeln, die der Server durchsetzt:** Aktennummern vergibt der Server
+(`SM--`), weil lokale Nummern bei allen Spielern mit 0001
+beginnen. Speichern mit `basis_version`: Weicht sie ab, kommt `konflikt`
+(409) mit dem Serverstand zurück. Ein Charakter ist in höchstens einem
+Squad; Einladungen muss der Besitzer annehmen; nimmt er an, verfallen seine
+anderen offenen Einladungen. Der Führer kann nur gehen, wenn er allein ist
+oder die Führung übergeben hat; wird er gelöscht, übernimmt das
+dienstälteste Mitglied. Porträts werden mit GD neu als PNG (≤ 512 px)
+gespeichert, das Original verworfen. Token liegen nur als SHA-256 in der
+Datenbank. Bremsen: Anmelden 10 je 15 min pro IP und Name, Registrieren 5
+je Stunde pro IP, Verwaltung 8 je 15 min.
+
+**Testen:** `werkzeuge/server_test.py` kopiert `server/` in einen
+Testordner, nutzt SQLite und Mails als Dateien und spielt über 90 Fälle
+durch — Einrichtung, Konten, Akten, Porträts, Squads, Verwaltung, Sperren,
+Bremsen. Braucht `php` im Suchpfad (auf dem Entwicklungsrechner PHP 8.4 aus
+winget). MySQL selbst ist lokal nicht testbar; `DB::sperre()` und
+`DB::schemaAnlegen()` enthalten die Unterschiede.
+
+---
+
## 5. Hart erkaufte Erkenntnisse
Diese Punkte wurden durch Fehlschläge gefunden. Wer sie „aufräumt", baut
diff --git a/installer/HOCHLADEN.txt b/installer/HOCHLADEN.txt
index 4be3c83..bbb1726 100644
--- a/installer/HOCHLADEN.txt
+++ b/installer/HOCHLADEN.txt
@@ -35,6 +35,43 @@ mit einer anderen Nummer als __VERSION__, und falls noch vorhanden:
Solange sie online liegen, kann jemand mit einer alten Fassung anfangen.
+KONTEN UND SQUADS: EINMALIG EINRICHTEN
+--------------------------------------
+Seit 1.6.0 gibt es Konten, Akten auf dem Server und Squads. Dafür liegt
+neben diesem Ordner zusätzlich dist\sva-privat. Einmalig:
+
+1. Den Ordner sva-privat in das Hauptverzeichnis des Webspace laden,
+ NEBEN den Ordner sva.tyrveil.com - nicht hinein. Im Plesk-Dateimanager
+ ist das die Ebene, auf der auch sva.tyrveil.com und httpdocs liegen.
+ Dort ist er aus dem Internet nicht erreichbar.
+
+2. In sva-privat die Datei config.beispiel.php kopieren und die Kopie
+ config.php nennen. Darin eintragen:
+ 'passwort' das Datenbank-Passwort aus Plesk
+ 'einrichtungs_schluessel' eine lange Zufallszeichenkette,
+ mindestens 24 Zeichen
+
+3. Den Inhalt von dist\server wie oben nach sva.tyrveil.com laden. Neu
+ dabei sind die Ordner api, konto, verwaltung und einrichten.php.
+
+4. https://sva.tyrveil.com/einrichten.php öffnen und den Schlüssel
+ eingeben. Die Seite prüft PHP, legt die Tabellen an und schickt an
+ info@tyrveil.com einen Link, mit dem du das Passwort für die
+ Verwaltung festlegst.
+
+5. In config.php den einrichtungs_schluessel wieder leeren: ''
+ Damit ist einrichten.php abgeschaltet.
+
+6. Die Verwaltung liegt unter https://sva.tyrveil.com/verwaltung/
+
+Zeigt einrichten.php "config.php fehlt", obwohl sie oben liegt: In Plesk
+unter PHP-Einstellungen muss open_basedir das Hauptverzeichnis des
+Webspace erlauben. Die Voreinstellung {WEBSPACEROOT}{/}{:}{TMP}{/} tut das.
+
+Bei späteren Updates nur sva-privat\app ersetzen. config.php und den
+Ordner daten (Porträts) nie überschreiben oder löschen.
+
+
ZUM VERTEILEN
-------------
Deinen Freunden gibst du nur noch diesen Link. Er ändert sich nie:
diff --git a/server/sva-privat/app/api.php b/server/sva-privat/app/api.php
new file mode 100644
index 0000000..8817762
--- /dev/null
+++ b/server/sva-privat/app/api.php
@@ -0,0 +1,166 @@
+ self::MAX_ANFRAGE_BYTES) {
+ throw new SmFehler('anfrage_zu_gross', 'Die Anfrage ist zu groß.', 413);
+ }
+ $anfrage = json_decode($roh, true);
+ if (!is_array($anfrage) || !is_string($anfrage['aktion'] ?? null)) {
+ throw new SmFehler('anfrage_ungueltig', 'Ungültige Anfrage.');
+ }
+ $aktion = $anfrage['aktion'];
+
+ $nutzer = null;
+ if (!in_array($aktion, self::OHNE_ANMELDUNG, true)) {
+ $nutzer = Sicherheit::sitzung((string) ($_SERVER['HTTP_X_SM_TOKEN'] ?? ''));
+ if ($nutzer === null) {
+ throw new SmFehler('nicht_angemeldet', 'Bitte melde dich an.', 401);
+ }
+ }
+ self::senden(['ok' => true] + self::ausfuehren($aktion, $anfrage, $nutzer));
+ } catch (SmFehler $fehler) {
+ self::senden(['ok' => false, 'fehler' => $fehler->fehlercode, 'meldung' => $fehler->getMessage()]
+ + $fehler->extra, $fehler->http);
+ } catch (Throwable $fehler) {
+ sm_log('API: ' . $fehler::class . ': ' . $fehler->getMessage() . ' in '
+ . $fehler->getFile() . ':' . $fehler->getLine());
+ self::senden(['ok' => false, 'fehler' => 'serverfehler',
+ 'meldung' => 'Auf dem Server ist ein Fehler aufgetreten.'], 500);
+ }
+ }
+
+ private static function ausfuehren(string $aktion, array $a, ?array $nutzer): array
+ {
+ switch ($aktion) {
+ case 'status':
+ return ['api' => SM_API_VERSION, 'zeit' => DB::jetzt()];
+
+ // -- Konto ------------------------------------------------------
+ case 'registrieren':
+ Konten::registrieren(self::text($a, 'benutzername', 64), self::text($a, 'email', 250),
+ self::text($a, 'passwort', 500));
+ return ['meldung' => 'Konto angelegt. Wir haben dir eine Mail zur Bestätigung geschickt.'];
+ case 'bestaetigung_erneut':
+ Konten::bestaetigungErneut(self::text($a, 'email', 250));
+ return ['meldung' => 'Falls ein unbestätigtes Konto zu dieser Adresse gehört, ist die Mail unterwegs.'];
+ case 'anmelden':
+ return Konten::anmelden(self::text($a, 'login', 250), self::text($a, 'passwort', 500),
+ self::text($a, 'geraet', 100));
+ case 'passwort_vergessen':
+ Konten::passwortVergessen(self::text($a, 'email', 250));
+ return ['meldung' => 'Falls ein Konto zu dieser Adresse gehört, ist die Mail unterwegs.'];
+ case 'abmelden':
+ Konten::abmelden($nutzer);
+ return [];
+ case 'ich':
+ return ['nutzer' => Konten::oeffentlich($nutzer)];
+ case 'konto_loeschen':
+ Konten::kontoLoeschen($nutzer, self::text($a, 'passwort', 500));
+ return [];
+
+ // -- Eigene Charaktere -------------------------------------------
+ case 'charaktere_eigene':
+ return ['charaktere' => Charaktere::eigene($nutzer)];
+ case 'charakter_speichern':
+ $basis = $a['basis_version'] ?? null;
+ return ['charakter' => Charaktere::speichern($nutzer, self::text($a, 'lokale_id', 64),
+ $a['daten'] ?? null, is_int($basis) ? $basis : null, ($a['erzwingen'] ?? false) === true)];
+ case 'charakter_loeschen':
+ Charaktere::loeschen($nutzer, self::text($a, 'lokale_id', 64));
+ return [];
+ case 'portraet_hochladen':
+ return ['charakter' => Charaktere::portraetSetzen($nutzer, self::text($a, 'lokale_id', 64),
+ self::text($a, 'bild', self::MAX_ANFRAGE_BYTES))];
+ case 'portraet_entfernen':
+ return ['charakter' => Charaktere::portraetEntfernen($nutzer, self::text($a, 'lokale_id', 64))];
+
+ // -- Alle Charaktere ---------------------------------------------
+ case 'charaktere_alle':
+ return ['charaktere' => Charaktere::alle($nutzer, self::text($a, 'suche', 64),
+ self::text($a, 'fraktion', 80))];
+ case 'charakter_ansehen':
+ return ['charakter' => Charaktere::ansehen($nutzer, self::zahl($a, 'id'))];
+
+ // -- Squads -------------------------------------------------------
+ case 'squads':
+ return ['squads' => Squads::liste($nutzer)];
+ case 'squad_ansehen':
+ return ['squad' => Squads::details($nutzer, self::zahl($a, 'squad_id'))];
+ case 'squad_gruenden':
+ return ['squad' => Squads::gruenden($nutzer, self::zahl($a, 'charakter_id'),
+ self::text($a, 'name', 100), self::text($a, 'beschreibung', 2000))];
+ case 'squad_einladen':
+ return ['einladung' => Squads::einladen($nutzer, self::zahl($a, 'squad_id'),
+ self::zahl($a, 'charakter_id'))];
+ case 'einladungen':
+ return Squads::einladungen($nutzer);
+ case 'einladung_beantworten':
+ Squads::beantworten($nutzer, self::zahl($a, 'einladung_id'), ($a['annehmen'] ?? false) === true);
+ return [];
+ case 'einladung_zurueckziehen':
+ Squads::zurueckziehen($nutzer, self::zahl($a, 'einladung_id'));
+ return [];
+ case 'squad_verlassen':
+ Squads::verlassen($nutzer, self::zahl($a, 'charakter_id'));
+ return [];
+ case 'squad_entfernen':
+ Squads::entfernen($nutzer, self::zahl($a, 'squad_id'), self::zahl($a, 'charakter_id'));
+ return [];
+ case 'squad_fuehrung_uebergeben':
+ Squads::fuehrungUebergeben($nutzer, self::zahl($a, 'squad_id'), self::zahl($a, 'charakter_id'));
+ return [];
+ case 'squad_aufloesen':
+ Squads::aufloesen($nutzer, self::zahl($a, 'squad_id'));
+ return [];
+ }
+ throw new SmFehler('aktion_unbekannt', 'Unbekannte Aktion.', 404);
+ }
+}
diff --git a/server/sva-privat/app/charaktere.php b/server/sva-privat/app/charaktere.php
new file mode 100644
index 0000000..2f21c44
--- /dev/null
+++ b/server/sva-privat/app/charaktere.php
@@ -0,0 +1,314 @@
+ self::text($p['callsign'] ?? '', 64),
+ 'vorname' => self::text($p['vorname'] ?? '', 64),
+ 'nachname' => self::text($p['nachname'] ?? '', 64),
+ 'fraktion' => self::text($d['fraktion'] ?? '', 80),
+ 'teilstreitkraft' => self::text($d['teilstreitkraft'] ?? '', 80),
+ 'rang' => self::text($d['rang'] ?? '', 120),
+ 'verwendung' => self::text($d['verwendung'] ?? '', 80),
+ 'status' => in_array($d['status'] ?? '', SM_STATUS, true) ? $d['status'] : 'aktiv',
+ ];
+ }
+
+ private static function squadKurz(array $zeile): ?array
+ {
+ if ($zeile['squad_id'] === null) {
+ return null;
+ }
+ $squad = DB::eine('SELECT id, name, fuehrer_id FROM sm_squad WHERE id = ?', [$zeile['squad_id']]);
+ return $squad === null ? null : [
+ 'id' => (int) $squad['id'],
+ 'name' => $squad['name'],
+ 'ist_fuehrer' => (int) $squad['fuehrer_id'] === (int) $zeile['id'],
+ ];
+ }
+
+ /** Vollstaendige Sicht auf einen eigenen Charakter. */
+ public static function eigeneZeile(array $zeile): array
+ {
+ return [
+ 'id' => (int) $zeile['id'],
+ 'lokale_id' => $zeile['lokale_id'],
+ 'aktennummer' => $zeile['aktennummer'],
+ 'version' => (int) $zeile['version'],
+ 'geaendert_am' => $zeile['geaendert_am'],
+ 'portraet' => $zeile['portraet'] !== null,
+ 'squad' => self::squadKurz($zeile),
+ 'daten' => json_decode($zeile['daten'], true) ?: new stdClass(),
+ ];
+ }
+
+ /** Kurzfassung fuer die Liste aller Charaktere. $zeile braucht "spieler" aus sm_nutzer. */
+ public static function zusammenfassung(array $zeile, array $betrachter): array
+ {
+ return [
+ 'id' => (int) $zeile['id'],
+ 'aktennummer' => $zeile['aktennummer'],
+ 'callsign' => $zeile['callsign'],
+ 'vorname' => $zeile['vorname'],
+ 'nachname' => $zeile['nachname'],
+ 'rang' => $zeile['rang'],
+ 'fraktion' => $zeile['fraktion'],
+ 'teilstreitkraft' => $zeile['teilstreitkraft'],
+ 'verwendung' => $zeile['verwendung'],
+ 'status' => $zeile['status'],
+ 'spieler' => $zeile['spieler'],
+ 'eigener' => (int) $zeile['nutzer_id'] === (int) $betrachter['id'],
+ 'portraet' => $zeile['portraet'] !== null,
+ 'squad' => self::squadKurz($zeile),
+ 'geaendert_am' => $zeile['geaendert_am'],
+ ];
+ }
+
+ public static function speichern(array $nutzer, string $lokaleId, mixed $daten,
+ ?int $basisVersion, bool $erzwingen): array
+ {
+ if (!preg_match('/^[0-9a-f]{32}$/', $lokaleId)) {
+ throw new SmFehler('lokale_id_ungueltig', 'Ungültige Akten-ID.');
+ }
+ if (!is_array($daten)) {
+ throw new SmFehler('daten_ungueltig', 'Die Akte ist unvollständig.');
+ }
+ if (strlen((string) json_encode($daten)) > self::MAX_DATEN_BYTES) {
+ throw new SmFehler('akte_zu_gross', 'Die Akte ist zu groß.', 413);
+ }
+ $felder = self::felder($daten);
+ $nutzerId = (int) $nutzer['id'];
+
+ return DB::transaktion(function () use ($nutzerId, $lokaleId, $daten, $felder, $basisVersion, $erzwingen) {
+ $vorhanden = DB::eine('SELECT * FROM sm_charakter WHERE nutzer_id = ? AND lokale_id = ?'
+ . DB::sperre(), [$nutzerId, $lokaleId]);
+ if ($vorhanden !== null) {
+ if ($basisVersion !== null && $basisVersion !== (int) $vorhanden['version'] && !$erzwingen) {
+ throw new SmFehler('konflikt', 'Die Akte wurde inzwischen an anderer Stelle geändert.',
+ 409, ['charakter' => self::eigeneZeile($vorhanden)]);
+ }
+ $id = (int) $vorhanden['id'];
+ $daten['aktennummer'] = $vorhanden['aktennummer'];
+ DB::aktualisieren('sm_charakter', $felder + [
+ 'daten' => self::json($daten),
+ 'version' => (int) $vorhanden['version'] + 1,
+ 'geaendert_am' => DB::jetzt(),
+ ], 'id = ?', [$id]);
+ } else {
+ $anzahl = (int) DB::wert('SELECT COUNT(*) FROM sm_charakter WHERE nutzer_id = ?', [$nutzerId]);
+ if ($anzahl >= self::MAX_JE_NUTZER) {
+ throw new SmFehler('zu_viele_charaktere',
+ 'Mehr als ' . self::MAX_JE_NUTZER . ' Charaktere pro Konto sind nicht möglich.', 409);
+ }
+ $id = DB::einfuegen('sm_charakter', $felder + [
+ 'nutzer_id' => $nutzerId,
+ 'lokale_id' => $lokaleId,
+ 'daten' => '{}',
+ 'version' => 1,
+ 'erstellt_am' => DB::jetzt(),
+ 'geaendert_am' => DB::jetzt(),
+ ]);
+ $daten['aktennummer'] = sprintf('SM-%s-%04d', gmdate('Y'), $id);
+ DB::aktualisieren('sm_charakter',
+ ['aktennummer' => $daten['aktennummer'], 'daten' => self::json($daten)], 'id = ?', [$id]);
+ }
+ return self::eigeneZeile(DB::eine('SELECT * FROM sm_charakter WHERE id = ?', [$id]));
+ });
+ }
+
+ private static function json(array $daten): string
+ {
+ return json_encode($daten, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);
+ }
+
+ public static function eigene(array $nutzer): array
+ {
+ $zeilen = DB::alle('SELECT * FROM sm_charakter WHERE nutzer_id = ? ORDER BY erstellt_am, id',
+ [$nutzer['id']]);
+ return array_map([self::class, 'eigeneZeile'], $zeilen);
+ }
+
+ private static function eigenerMitSperre(array $nutzer, string $lokaleId): array
+ {
+ $zeile = DB::eine('SELECT * FROM sm_charakter WHERE nutzer_id = ? AND lokale_id = ?' . DB::sperre(),
+ [$nutzer['id'], $lokaleId]);
+ if ($zeile === null) {
+ throw new SmFehler('charakter_nicht_gefunden', 'Diese Akte gibt es auf dem Server nicht.', 404);
+ }
+ return $zeile;
+ }
+
+ public static function loeschen(array $nutzer, string $lokaleId): void
+ {
+ DB::transaktion(function () use ($nutzer, $lokaleId) {
+ self::loeschenIntern(self::eigenerMitSperre($nutzer, $lokaleId));
+ });
+ }
+
+ /** Fuer die Verwaltung: Loeschen ohne Besitzpruefung. */
+ public static function loeschenNachId(int $id): void
+ {
+ DB::transaktion(function () use ($id) {
+ $zeile = DB::eine('SELECT * FROM sm_charakter WHERE id = ?' . DB::sperre(), [$id]);
+ if ($zeile !== null) {
+ self::loeschenIntern($zeile);
+ }
+ });
+ }
+
+ private static function loeschenIntern(array $zeile): void
+ {
+ Squads::beimLoeschen($zeile);
+ self::bildDateiLoeschen($zeile['portraet']);
+ DB::ausfuehren('DELETE FROM sm_charakter WHERE id = ?', [$zeile['id']]);
+ }
+
+ public static function alleVonNutzerLoeschen(int $nutzerId): void
+ {
+ foreach (DB::alle('SELECT * FROM sm_charakter WHERE nutzer_id = ?', [$nutzerId]) as $zeile) {
+ self::loeschenIntern($zeile);
+ }
+ }
+
+ // -- Portraets ---------------------------------------------------------
+
+ private static function bildDateiLoeschen(?string $datei): void
+ {
+ if ($datei !== null && preg_match('/^[0-9]+-[0-9a-f]{16}\.png$/', $datei)) {
+ @unlink(sm_daten_ordner('portraets') . '/' . $datei);
+ }
+ }
+
+ /**
+ * Nimmt ein Bild an und speichert es neu als PNG, hoechstens 512 Pixel.
+ * Das Neuzeichnen verwirft alles ausser den Bildpunkten - eingeschleuster
+ * Code in einer Bilddatei kommt so nicht auf den Server.
+ */
+ public static function portraetSetzen(array $nutzer, string $lokaleId, string $base64): array
+ {
+ if (!function_exists('imagecreatefromstring')) {
+ throw new SmFehler('server_ohne_gd', 'Der Server kann gerade keine Bilder verarbeiten.', 500);
+ }
+ $roh = base64_decode($base64, true);
+ if ($roh === false || $roh === '') {
+ throw new SmFehler('bild_ungueltig', 'Das Bild konnte nicht gelesen werden.');
+ }
+ if (strlen($roh) > self::MAX_BILD_BYTES) {
+ throw new SmFehler('bild_zu_gross', 'Das Bild ist zu groß (höchstens 8 MB).', 413);
+ }
+ $info = @getimagesizefromstring($roh);
+ $erlaubt = [IMAGETYPE_JPEG, IMAGETYPE_PNG, IMAGETYPE_WEBP, IMAGETYPE_GIF];
+ if ($info === false || !in_array($info[2], $erlaubt, true)) {
+ throw new SmFehler('bild_ungueltig', 'Erlaubt sind JPG, PNG, WebP und GIF.');
+ }
+ if ($info[0] * $info[1] > 40_000_000) {
+ throw new SmFehler('bild_zu_gross', 'Das Bild hat zu viele Bildpunkte.', 413);
+ }
+ $quelle = @imagecreatefromstring($roh);
+ if ($quelle === false) {
+ throw new SmFehler('bild_ungueltig', 'Das Bild konnte nicht gelesen werden.');
+ }
+ [$breite, $hoehe] = [imagesx($quelle), imagesy($quelle)];
+ $faktor = min(1, self::BILD_KANTE / max($breite, $hoehe));
+ $nb = max(1, (int) round($breite * $faktor));
+ $nh = max(1, (int) round($hoehe * $faktor));
+ $ziel = imagecreatetruecolor($nb, $nh);
+ imagealphablending($ziel, false);
+ imagesavealpha($ziel, true);
+ imagefill($ziel, 0, 0, imagecolorallocatealpha($ziel, 0, 0, 0, 127));
+ imagecopyresampled($ziel, $quelle, 0, 0, 0, 0, $nb, $nh, $breite, $hoehe);
+
+ return DB::transaktion(function () use ($nutzer, $lokaleId, $ziel) {
+ $zeile = self::eigenerMitSperre($nutzer, $lokaleId);
+ $datei = $zeile['id'] . '-' . Sicherheit::zufall(8) . '.png';
+ if (!imagepng($ziel, sm_daten_ordner('portraets') . '/' . $datei, 6)) {
+ throw new SmFehler('bild_speichern', 'Das Bild konnte nicht gespeichert werden.', 500);
+ }
+ self::bildDateiLoeschen($zeile['portraet']);
+ DB::aktualisieren('sm_charakter', ['portraet' => $datei, 'geaendert_am' => DB::jetzt()],
+ 'id = ?', [$zeile['id']]);
+ return self::eigeneZeile(DB::eine('SELECT * FROM sm_charakter WHERE id = ?', [$zeile['id']]));
+ });
+ }
+
+ public static function portraetEntfernen(array $nutzer, string $lokaleId): array
+ {
+ return DB::transaktion(function () use ($nutzer, $lokaleId) {
+ $zeile = self::eigenerMitSperre($nutzer, $lokaleId);
+ self::bildDateiLoeschen($zeile['portraet']);
+ DB::aktualisieren('sm_charakter', ['portraet' => null, 'geaendert_am' => DB::jetzt()],
+ 'id = ?', [$zeile['id']]);
+ return self::eigeneZeile(DB::eine('SELECT * FROM sm_charakter WHERE id = ?', [$zeile['id']]));
+ });
+ }
+
+ /** Pfad zur Bilddatei eines Charakters oder null. */
+ public static function bildPfad(int $id): ?string
+ {
+ $datei = DB::wert('SELECT portraet FROM sm_charakter WHERE id = ?', [$id]);
+ if (!is_string($datei) || !preg_match('/^[0-9]+-[0-9a-f]{16}\.png$/', $datei)) {
+ return null;
+ }
+ $pfad = sm_daten_ordner('portraets') . '/' . $datei;
+ return is_file($pfad) ? $pfad : null;
+ }
+
+ // -- Fuer alle sichtbar -------------------------------------------------
+
+ private const LISTE_SQL = 'SELECT c.*, n.benutzername AS spieler
+ FROM sm_charakter c JOIN sm_nutzer n ON n.id = c.nutzer_id
+ WHERE n.gesperrt = 0';
+
+ public static function alle(array $nutzer, string $suche = '', string $fraktion = ''): array
+ {
+ $sql = self::LISTE_SQL;
+ $werte = [];
+ $suche = trim($suche);
+ if ($suche !== '') {
+ $muster = '%' . str_replace(['!', '%', '_'], ['!!', '!%', '!_'], mb_substr($suche, 0, 64)) . '%';
+ $sql .= " AND (c.callsign LIKE ? ESCAPE '!' OR c.vorname LIKE ? ESCAPE '!'"
+ . " OR c.nachname LIKE ? ESCAPE '!' OR n.benutzername LIKE ? ESCAPE '!')";
+ array_push($werte, $muster, $muster, $muster, $muster);
+ }
+ if (trim($fraktion) !== '') {
+ $sql .= ' AND c.fraktion = ?';
+ $werte[] = trim($fraktion);
+ }
+ $sql .= ' ORDER BY c.callsign, c.nachname, c.id LIMIT 500';
+ return array_map(fn($zeile) => self::zusammenfassung($zeile, $nutzer), DB::alle($sql, $werte));
+ }
+
+ public static function ansehen(array $nutzer, int $id): array
+ {
+ $zeile = DB::eine(self::LISTE_SQL . ' AND c.id = ?', [$id]);
+ if ($zeile === null) {
+ throw new SmFehler('charakter_nicht_gefunden', 'Diesen Charakter gibt es nicht.', 404);
+ }
+ return self::zusammenfassung($zeile, $nutzer)
+ + ['daten' => json_decode($zeile['daten'], true) ?: new stdClass()];
+ }
+}
diff --git a/server/sva-privat/app/db.php b/server/sva-privat/app/db.php
new file mode 100644
index 0000000..3170a17
--- /dev/null
+++ b/server/sva-privat/app/db.php
@@ -0,0 +1,236 @@
+ PDO::ERRMODE_EXCEPTION,
+ PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
+ PDO::ATTR_EMULATE_PREPARES => false,
+ ],
+ );
+ if (self::sqlite()) {
+ self::$pdo->exec('PRAGMA foreign_keys = ON');
+ self::$pdo->exec('PRAGMA busy_timeout = 5000');
+ }
+ }
+ return self::$pdo;
+ }
+
+ public static function sqlite(): bool
+ {
+ return str_starts_with((string) sm_config('datenbank.dsn'), 'sqlite:');
+ }
+
+ public static function jetzt(int $plusSekunden = 0): string
+ {
+ return gmdate('Y-m-d H:i:s', time() + $plusSekunden);
+ }
+
+ public static function alle(string $sql, array $werte = []): array
+ {
+ $abfrage = self::pdo()->prepare($sql);
+ $abfrage->execute($werte);
+ return $abfrage->fetchAll();
+ }
+
+ public static function eine(string $sql, array $werte = []): ?array
+ {
+ $abfrage = self::pdo()->prepare($sql);
+ $abfrage->execute($werte);
+ $zeile = $abfrage->fetch();
+ return $zeile === false ? null : $zeile;
+ }
+
+ public static function wert(string $sql, array $werte = []): mixed
+ {
+ $abfrage = self::pdo()->prepare($sql);
+ $abfrage->execute($werte);
+ $wert = $abfrage->fetchColumn();
+ return $wert === false ? null : $wert;
+ }
+
+ public static function ausfuehren(string $sql, array $werte = []): int
+ {
+ $abfrage = self::pdo()->prepare($sql);
+ $abfrage->execute($werte);
+ return $abfrage->rowCount();
+ }
+
+ public static function einfuegen(string $tabelle, array $werte): int
+ {
+ $spalten = array_keys($werte);
+ $sql = sprintf('INSERT INTO %s (%s) VALUES (%s)', $tabelle,
+ implode(', ', $spalten), implode(', ', array_fill(0, count($spalten), '?')));
+ self::ausfuehren($sql, array_values($werte));
+ return (int) self::pdo()->lastInsertId();
+ }
+
+ public static function aktualisieren(string $tabelle, array $werte, string $bedingung,
+ array $bedingungWerte): int
+ {
+ $teile = array_map(fn($spalte) => "$spalte = ?", array_keys($werte));
+ $sql = sprintf('UPDATE %s SET %s WHERE %s', $tabelle, implode(', ', $teile), $bedingung);
+ return self::ausfuehren($sql, [...array_values($werte), ...$bedingungWerte]);
+ }
+
+ /** Fuehrt $arbeit in einer Transaktion aus; bei einer Ausnahme wird alles zurueckgenommen. */
+ public static function transaktion(callable $arbeit): mixed
+ {
+ $pdo = self::pdo();
+ $pdo->beginTransaction();
+ try {
+ $ergebnis = $arbeit();
+ $pdo->commit();
+ return $ergebnis;
+ } catch (Throwable $fehler) {
+ $pdo->rollBack();
+ throw $fehler;
+ }
+ }
+
+ /**
+ * Zeilensperre fuer SELECT innerhalb einer Transaktion. Verhindert etwa,
+ * dass zwei gleichzeitige Einladungen denselben Charakter in zwei Squads
+ * bringen. SQLite sperrt ohnehin die ganze Datenbank beim Schreiben.
+ */
+ public static function sperre(): string
+ {
+ return self::sqlite() ? '' : ' FOR UPDATE';
+ }
+
+ /** Legt fehlende Tabellen an. Gibt die Namen aller Tabellen zurueck. */
+ public static function schemaAnlegen(): array
+ {
+ $sqlite = self::sqlite();
+ $id = $sqlite ? 'INTEGER PRIMARY KEY AUTOINCREMENT' : 'INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY';
+ $ref = $sqlite ? 'INTEGER' : 'INT UNSIGNED';
+ $lang = $sqlite ? 'TEXT' : 'MEDIUMTEXT';
+ $ende = $sqlite ? ')' : ') ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci';
+
+ $tabellen = [
+ 'sm_meta' => "CREATE TABLE IF NOT EXISTS sm_meta (
+ schluessel VARCHAR(64) NOT NULL PRIMARY KEY,
+ wert TEXT NULL
+ $ende",
+ 'sm_nutzer' => "CREATE TABLE IF NOT EXISTS sm_nutzer (
+ id $id,
+ benutzername VARCHAR(32) NOT NULL,
+ benutzername_klein VARCHAR(32) NOT NULL,
+ email VARCHAR(191) NOT NULL,
+ passwort_hash VARCHAR(255) NULL,
+ rolle VARCHAR(16) NOT NULL DEFAULT 'nutzer',
+ email_bestaetigt_am DATETIME NULL,
+ gesperrt TINYINT NOT NULL DEFAULT 0,
+ erstellt_am DATETIME NOT NULL,
+ letzte_anmeldung_am DATETIME NULL,
+ UNIQUE (benutzername_klein),
+ UNIQUE (email)
+ $ende",
+ 'sm_token' => "CREATE TABLE IF NOT EXISTS sm_token (
+ id $id,
+ nutzer_id $ref NOT NULL,
+ art VARCHAR(16) NOT NULL,
+ token_hash CHAR(64) NOT NULL,
+ geraet VARCHAR(100) NULL,
+ erstellt_am DATETIME NOT NULL,
+ laeuft_ab_am DATETIME NOT NULL,
+ genutzt_am DATETIME NULL,
+ UNIQUE (token_hash),
+ FOREIGN KEY (nutzer_id) REFERENCES sm_nutzer (id) ON DELETE CASCADE
+ $ende",
+ 'sm_squad' => "CREATE TABLE IF NOT EXISTS sm_squad (
+ id $id,
+ name VARCHAR(48) NOT NULL,
+ name_klein VARCHAR(48) NOT NULL,
+ beschreibung TEXT NULL,
+ fuehrer_id $ref NULL,
+ erstellt_am DATETIME NOT NULL,
+ UNIQUE (name_klein)
+ $ende",
+ 'sm_charakter' => "CREATE TABLE IF NOT EXISTS sm_charakter (
+ id $id,
+ nutzer_id $ref NOT NULL,
+ lokale_id CHAR(32) NOT NULL,
+ aktennummer VARCHAR(24) NULL,
+ callsign VARCHAR(64) NOT NULL DEFAULT '',
+ vorname VARCHAR(64) NOT NULL DEFAULT '',
+ nachname VARCHAR(64) NOT NULL DEFAULT '',
+ fraktion VARCHAR(80) NOT NULL DEFAULT '',
+ teilstreitkraft VARCHAR(80) NOT NULL DEFAULT '',
+ rang VARCHAR(120) NOT NULL DEFAULT '',
+ verwendung VARCHAR(80) NOT NULL DEFAULT '',
+ status VARCHAR(20) NOT NULL DEFAULT 'aktiv',
+ daten $lang NOT NULL,
+ portraet VARCHAR(80) NULL,
+ squad_id $ref NULL,
+ squad_seit DATETIME NULL,
+ version INT NOT NULL DEFAULT 1,
+ erstellt_am DATETIME NOT NULL,
+ geaendert_am DATETIME NOT NULL,
+ UNIQUE (nutzer_id, lokale_id),
+ UNIQUE (aktennummer),
+ FOREIGN KEY (nutzer_id) REFERENCES sm_nutzer (id) ON DELETE CASCADE,
+ FOREIGN KEY (squad_id) REFERENCES sm_squad (id) ON DELETE SET NULL
+ $ende",
+ 'sm_einladung' => "CREATE TABLE IF NOT EXISTS sm_einladung (
+ id $id,
+ squad_id $ref NOT NULL,
+ charakter_id $ref NOT NULL,
+ von_charakter_id $ref NULL,
+ status VARCHAR(16) NOT NULL DEFAULT 'offen',
+ erstellt_am DATETIME NOT NULL,
+ beantwortet_am DATETIME NULL,
+ FOREIGN KEY (squad_id) REFERENCES sm_squad (id) ON DELETE CASCADE,
+ FOREIGN KEY (charakter_id) REFERENCES sm_charakter (id) ON DELETE CASCADE
+ $ende",
+ 'sm_versuch' => "CREATE TABLE IF NOT EXISTS sm_versuch (
+ id $id,
+ art VARCHAR(16) NOT NULL,
+ schluessel CHAR(64) NOT NULL,
+ zeit DATETIME NOT NULL
+ $ende",
+ ];
+ foreach ($tabellen as $sql) {
+ self::pdo()->exec($sql);
+ }
+
+ // Nicht eindeutige Indizes: SQLite kennt IF NOT EXISTS, MySQL nicht
+ $indizes = [
+ ['sm_charakter', 'ix_charakter_squad', 'squad_id'],
+ ['sm_einladung', 'ix_einladung_charakter', 'charakter_id, status'],
+ ['sm_einladung', 'ix_einladung_squad', 'squad_id, status'],
+ ['sm_versuch', 'ix_versuch', 'art, schluessel, zeit'],
+ ['sm_token', 'ix_token_nutzer', 'nutzer_id, art'],
+ ];
+ foreach ($indizes as [$tabelle, $name, $spalten]) {
+ if ($sqlite) {
+ self::pdo()->exec("CREATE INDEX IF NOT EXISTS $name ON $tabelle ($spalten)");
+ } elseif (!self::wert("SELECT COUNT(*) FROM information_schema.statistics
+ WHERE table_schema = DATABASE() AND table_name = ? AND index_name = ?",
+ [$tabelle, $name])) {
+ self::pdo()->exec("CREATE INDEX $name ON $tabelle ($spalten)");
+ }
+ }
+
+ self::ausfuehren('DELETE FROM sm_meta WHERE schluessel = ?', ['schema']);
+ self::einfuegen('sm_meta', ['schluessel' => 'schema', 'wert' => '1']);
+ return array_keys($tabellen);
+ }
+}
diff --git a/server/sva-privat/app/konten.php b/server/sva-privat/app/konten.php
new file mode 100644
index 0000000..eff10f2
--- /dev/null
+++ b/server/sva-privat/app/konten.php
@@ -0,0 +1,209 @@
+ (int) $nutzer['id'],
+ 'benutzername' => $nutzer['benutzername'],
+ 'email' => $nutzer['email'],
+ 'rolle' => $nutzer['rolle'],
+ ];
+ }
+
+ public static function link(string $pfad): string
+ {
+ return rtrim((string) sm_config('basis_url', 'https://sva.tyrveil.com'), '/') . $pfad;
+ }
+
+ public static function registrieren(string $benutzername, string $email, string $passwort): void
+ {
+ $benutzername = trim($benutzername);
+ $email = mb_strtolower(trim($email));
+ if (!preg_match('/^[A-Za-z0-9_.-]{3,32}$/', $benutzername)) {
+ throw new SmFehler('benutzername_ungueltig', 'Der Benutzername braucht 3 bis 32 Zeichen: '
+ . 'Buchstaben, Ziffern, Punkt, Minus oder Unterstrich.');
+ }
+ if (strlen($email) > 191 || !filter_var($email, FILTER_VALIDATE_EMAIL)) {
+ throw new SmFehler('email_ungueltig', 'Die E-Mail-Adresse ist ungültig.');
+ }
+ $regel = Sicherheit::passwortRegeln($passwort);
+ if ($regel !== null) {
+ throw new SmFehler('passwort_zu_schwach', $regel);
+ }
+ Sicherheit::bremseOderFehler('registrieren', Sicherheit::ip(), 5, 3600);
+
+ if (DB::wert('SELECT 1 FROM sm_nutzer WHERE benutzername_klein = ?', [mb_strtolower($benutzername)])) {
+ throw new SmFehler('benutzername_vergeben', 'Dieser Benutzername ist schon vergeben.', 409);
+ }
+ if (DB::wert('SELECT 1 FROM sm_nutzer WHERE email = ?', [$email])) {
+ throw new SmFehler('email_vergeben',
+ 'Mit dieser E-Mail-Adresse gibt es schon ein Konto. Passwort vergessen?', 409);
+ }
+ try {
+ $id = DB::einfuegen('sm_nutzer', [
+ 'benutzername' => $benutzername,
+ 'benutzername_klein' => mb_strtolower($benutzername),
+ 'email' => $email,
+ 'passwort_hash' => Sicherheit::passwortHash($passwort),
+ 'rolle' => 'nutzer',
+ 'gesperrt' => 0,
+ 'erstellt_am' => DB::jetzt(),
+ ]);
+ } catch (PDOException $fehler) {
+ // Zwei gleichzeitige Registrierungen mit demselben Namen
+ if ((string) $fehler->getCode() === '23000') {
+ throw new SmFehler('benutzername_vergeben', 'Benutzername oder E-Mail ist schon vergeben.', 409);
+ }
+ throw $fehler;
+ }
+ self::bestaetigungSenden($id, $benutzername, $email);
+ }
+
+ private static function bestaetigungSenden(int $nutzerId, string $benutzername, string $email): void
+ {
+ Sicherheit::alleTokenLoeschen($nutzerId, 'bestaetigung');
+ $token = Sicherheit::tokenAnlegen($nutzerId, 'bestaetigung', 48 * 3600);
+ $link = self::link('/konto/bestaetigen.php?t=' . $token);
+ Mail::senden($email, 'Squad Manager: E-Mail-Adresse bestätigen',
+ "Hallo $benutzername,\n\n"
+ . "bitte bestätige deine E-Mail-Adresse, damit du dich im Squad Manager anmelden kannst:\n\n"
+ . "$link\n\n"
+ . "Der Link ist 48 Stunden gültig. Hast du kein Konto angelegt, ignoriere diese Mail einfach."
+ . Mail::fusszeile());
+ }
+
+ public static function bestaetigen(string $token): array
+ {
+ $zeile = Sicherheit::tokenFinden($token, 'bestaetigung');
+ if ($zeile === null) {
+ throw new SmFehler('link_ungueltig', 'Dieser Link ist ungültig oder abgelaufen.', 404);
+ }
+ if ($zeile['email_bestaetigt_am'] === null) {
+ DB::aktualisieren('sm_nutzer', ['email_bestaetigt_am' => DB::jetzt()], 'id = ?', [$zeile['id']]);
+ }
+ Sicherheit::tokenLoeschen((int) $zeile['token_id']);
+ return $zeile;
+ }
+
+ /** Antwortet immer gleich, damit sich nicht erraten laesst, welche Adressen registriert sind. */
+ public static function bestaetigungErneut(string $email): void
+ {
+ $email = mb_strtolower(trim($email));
+ Sicherheit::bremseOderFehler('bestaetigung', Sicherheit::ip(), 5, 3600);
+ $nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE email = ?', [$email]);
+ if ($nutzer && $nutzer['email_bestaetigt_am'] === null && !(int) $nutzer['gesperrt']
+ && Sicherheit::bremse('bestaetigung_mail', $email, 3, 3600)) {
+ self::bestaetigungSenden((int) $nutzer['id'], $nutzer['benutzername'], $nutzer['email']);
+ }
+ }
+
+ public static function anmelden(string $login, string $passwort, string $geraet): array
+ {
+ $login = mb_strtolower(trim($login));
+ Sicherheit::bremseOderFehler('anmelden', Sicherheit::ip() . '|' . $login, 10, 900);
+
+ $nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE benutzername_klein = ? OR email = ?', [$login, $login]);
+ $hash = $nutzer['passwort_hash'] ?? null;
+ // Auch ohne Nutzer einen echten Hash pruefen, sonst verraet die
+ // Antwortzeit, welche Namen existieren
+ $passt = password_verify($passwort, $hash ?? password_hash('platzhalter', PASSWORD_DEFAULT));
+ if (!$nutzer || $hash === null || !$passt) {
+ throw new SmFehler('anmeldung_falsch', 'Benutzername oder Passwort stimmt nicht.', 401);
+ }
+ if ((int) $nutzer['gesperrt'] === 1) {
+ throw new SmFehler('gesperrt', 'Dieses Konto ist gesperrt.', 403);
+ }
+ if ($nutzer['email_bestaetigt_am'] === null) {
+ throw new SmFehler('nicht_bestaetigt',
+ 'Bitte bestätige zuerst deine E-Mail-Adresse – der Link steht in der Mail von uns.', 403);
+ }
+ if (password_needs_rehash($hash, PASSWORD_DEFAULT)) {
+ DB::aktualisieren('sm_nutzer', ['passwort_hash' => Sicherheit::passwortHash($passwort)],
+ 'id = ?', [$nutzer['id']]);
+ }
+ Sicherheit::bremseLoesen('anmelden', Sicherheit::ip() . '|' . $login);
+ $token = Sicherheit::tokenAnlegen((int) $nutzer['id'], 'sitzung',
+ Sicherheit::SITZUNG_TAGE * 86400, $geraet);
+ DB::aktualisieren('sm_nutzer', ['letzte_anmeldung_am' => DB::jetzt()], 'id = ?', [$nutzer['id']]);
+ return ['token' => $token, 'nutzer' => self::oeffentlich($nutzer)];
+ }
+
+ public static function abmelden(array $nutzer): void
+ {
+ Sicherheit::tokenLoeschen((int) $nutzer['token_id']);
+ }
+
+ public static function passwortVergessen(string $email): void
+ {
+ $email = mb_strtolower(trim($email));
+ Sicherheit::bremseOderFehler('vergessen', Sicherheit::ip(), 5, 3600);
+ $nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE email = ?', [$email]);
+ if ($nutzer && !(int) $nutzer['gesperrt'] && Sicherheit::bremse('vergessen_mail', $email, 3, 3600)) {
+ self::passwortLinkSenden($nutzer, 3600,
+ "jemand – hoffentlich du – möchte das Passwort für deinen Squad Manager-Zugang zurücksetzen.\n\n"
+ . "Neues Passwort festlegen:\n\n%LINK%\n\n"
+ . "Der Link ist eine Stunde gültig. Warst du das nicht, ignoriere diese Mail; "
+ . "dein Passwort bleibt dann unverändert.");
+ }
+ }
+
+ /** Verschickt einen Link zum Passwort-Setzen. Gibt den Link zurueck (fuer die Einrichtung). */
+ public static function passwortLinkSenden(array $nutzer, int $gueltigSekunden, string $text): string
+ {
+ Sicherheit::alleTokenLoeschen((int) $nutzer['id'], 'passwort');
+ $token = Sicherheit::tokenAnlegen((int) $nutzer['id'], 'passwort', $gueltigSekunden);
+ $link = self::link('/konto/passwort.php?t=' . $token);
+ Mail::senden($nutzer['email'], 'Squad Manager: Passwort festlegen',
+ "Hallo {$nutzer['benutzername']},\n\n" . str_replace('%LINK%', $link, $text) . Mail::fusszeile());
+ return $link;
+ }
+
+ public static function passwortSetzen(string $token, string $passwort): array
+ {
+ $zeile = Sicherheit::tokenFinden($token, 'passwort');
+ if ($zeile === null) {
+ throw new SmFehler('link_ungueltig', 'Dieser Link ist ungültig oder abgelaufen.', 404);
+ }
+ $regel = Sicherheit::passwortRegeln($passwort);
+ if ($regel !== null) {
+ throw new SmFehler('passwort_zu_schwach', $regel);
+ }
+ DB::transaktion(function () use ($zeile, $passwort) {
+ // Wer den Link aus der Mail nutzt, hat die Adresse damit auch bestaetigt
+ DB::aktualisieren('sm_nutzer', [
+ 'passwort_hash' => Sicherheit::passwortHash($passwort),
+ 'email_bestaetigt_am' => $zeile['email_bestaetigt_am'] ?? DB::jetzt(),
+ ], 'id = ?', [$zeile['id']]);
+ Sicherheit::alleTokenLoeschen((int) $zeile['id'], 'passwort');
+ Sicherheit::alleTokenLoeschen((int) $zeile['id'], 'sitzung');
+ });
+ return $zeile;
+ }
+
+ public static function kontoLoeschen(array $nutzer, string $passwort): void
+ {
+ if ($nutzer['passwort_hash'] === null || !password_verify($passwort, $nutzer['passwort_hash'])) {
+ throw new SmFehler('anmeldung_falsch', 'Das Passwort stimmt nicht.', 401);
+ }
+ if ($nutzer['rolle'] === 'admin') {
+ throw new SmFehler('admin', 'Der Verwaltungszugang lässt sich nicht selbst löschen.', 403);
+ }
+ self::loeschen((int) $nutzer['id']);
+ }
+
+ /** Loescht Konto samt Charakteren; Squads werden dabei weitergegeben oder aufgeloest. */
+ public static function loeschen(int $nutzerId): void
+ {
+ DB::transaktion(function () use ($nutzerId) {
+ Charaktere::alleVonNutzerLoeschen($nutzerId);
+ DB::ausfuehren('DELETE FROM sm_nutzer WHERE id = ?', [$nutzerId]);
+ });
+ }
+}
diff --git a/server/sva-privat/app/mail.php b/server/sva-privat/app/mail.php
new file mode 100644
index 0000000..0839679
--- /dev/null
+++ b/server/sva-privat/app/mail.php
@@ -0,0 +1,121 @@
+ sprintf('%s <%s>', mb_encode_mimeheader($name, 'UTF-8', 'Q'), $absender),
+ 'Reply-To' => $absender,
+ 'MIME-Version' => '1.0',
+ 'Content-Type' => 'text/plain; charset=UTF-8',
+ 'Content-Transfer-Encoding' => 'quoted-printable',
+ 'X-Mailer' => 'Squad Manager',
+ ];
+ $betreffKodiert = mb_encode_mimeheader($betreff, 'UTF-8', 'Q');
+ $inhalt = quoted_printable_encode(str_replace(["\r\n", "\r"], "\n", $text));
+
+ try {
+ return match ((string) sm_config('mail.art', 'php_mail')) {
+ 'datei' => self::alsDatei($an, $betreffKodiert, $kopf, $inhalt),
+ 'smtp' => self::ueberSmtp($an, $betreffKodiert, $kopf, $inhalt, $absender),
+ default => mail($an, $betreffKodiert, str_replace("\n", "\r\n", $inhalt),
+ $kopf, '-f' . $absender),
+ };
+ } catch (Throwable $fehler) {
+ sm_log('Mailversand an ' . $an . ' gescheitert: ' . $fehler->getMessage());
+ return false;
+ }
+ }
+
+ private static function alsDatei(string $an, string $betreff, array $kopf, string $inhalt): bool
+ {
+ $zeilen = ["To: $an", "Subject: $betreff"];
+ foreach ($kopf as $schluessel => $wert) {
+ $zeilen[] = "$schluessel: $wert";
+ }
+ $datei = sm_daten_ordner('mails') . '/' . gmdate('Ymd-His') . '-' . Sicherheit::zufall(4) . '.eml';
+ return file_put_contents($datei, implode("\r\n", $zeilen) . "\r\n\r\n" . $inhalt) !== false;
+ }
+
+ private static function ueberSmtp(string $an, string $betreff, array $kopf, string $inhalt,
+ string $absender): bool
+ {
+ $host = (string) sm_config('mail.smtp.host', 'localhost');
+ $port = (int) sm_config('mail.smtp.port', 587);
+ $art = (string) sm_config('mail.smtp.verschluesselung', 'tls');
+ $adresse = ($art === 'ssl' ? 'ssl://' : 'tcp://') . "$host:$port";
+ $verbindung = @stream_socket_client($adresse, $nr, $meldung, 15);
+ if ($verbindung === false) {
+ throw new RuntimeException("SMTP-Verbindung zu $adresse: $meldung");
+ }
+ stream_set_timeout($verbindung, 15);
+
+ $lesen = function (int $erwartet) use ($verbindung): string {
+ $antwort = '';
+ while (($zeile = fgets($verbindung, 1024)) !== false) {
+ $antwort .= $zeile;
+ if (strlen($zeile) < 4 || $zeile[3] === ' ') {
+ break;
+ }
+ }
+ if ((int) substr($antwort, 0, 3) !== $erwartet) {
+ throw new RuntimeException('SMTP: ' . trim($antwort));
+ }
+ return $antwort;
+ };
+ $schreiben = function (string $befehl, int $erwartet) use ($verbindung, $lesen): string {
+ fwrite($verbindung, $befehl . "\r\n");
+ return $lesen($erwartet);
+ };
+
+ $lesen(220);
+ $schreiben('EHLO sva.tyrveil.com', 250);
+ if ($art === 'tls') {
+ $schreiben('STARTTLS', 220);
+ if (!stream_socket_enable_crypto($verbindung, true, STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
+ throw new RuntimeException('SMTP: STARTTLS gescheitert');
+ }
+ $schreiben('EHLO sva.tyrveil.com', 250);
+ }
+ $benutzer = (string) sm_config('mail.smtp.benutzer', '');
+ if ($benutzer !== '') {
+ $schreiben('AUTH LOGIN', 334);
+ $schreiben(base64_encode($benutzer), 334);
+ $schreiben(base64_encode((string) sm_config('mail.smtp.passwort', '')), 235);
+ }
+ $schreiben("MAIL FROM:<$absender>", 250);
+ $schreiben("RCPT TO:<$an>", 250);
+ $schreiben('DATA', 354);
+
+ $nachricht = ["To: $an", "Subject: $betreff", 'Date: ' . date(DATE_RFC2822)];
+ foreach ($kopf as $schluessel => $wert) {
+ $nachricht[] = "$schluessel: $wert";
+ }
+ $daten = implode("\r\n", $nachricht) . "\r\n\r\n" . str_replace("\n", "\r\n", $inhalt);
+ // Punkt am Zeilenanfang verdoppeln, sonst endet DATA vorzeitig
+ $daten = preg_replace('/^\./m', '..', $daten);
+ $schreiben($daten . "\r\n.", 250);
+ fwrite($verbindung, "QUIT\r\n");
+ fclose($verbindung);
+ return true;
+ }
+
+ public static function fusszeile(): string
+ {
+ return "\n\n-- \nSquad Manager · " . sm_config('basis_url', 'https://sva.tyrveil.com')
+ . "\nImpressum und Datenschutz: "
+ . sm_config('rechtliches_url', 'https://tyrveil.com/rechtliches#impressum');
+ }
+}
diff --git a/server/sva-privat/app/sicherheit.php b/server/sva-privat/app/sicherheit.php
new file mode 100644
index 0000000..b87a054
--- /dev/null
+++ b/server/sva-privat/app/sicherheit.php
@@ -0,0 +1,144 @@
+ $nutzerId,
+ 'art' => $art,
+ 'token_hash' => self::hash($token),
+ 'geraet' => $geraet === null ? null : mb_substr($geraet, 0, 100),
+ 'erstellt_am' => DB::jetzt(),
+ 'laeuft_ab_am' => DB::jetzt($gueltigSekunden),
+ ]);
+ return $token;
+ }
+
+ /** Gueltiges Token samt Nutzer, sonst null. */
+ public static function tokenFinden(string $token, string $art): ?array
+ {
+ if (!preg_match('/^[0-9a-f]{64}$/', $token)) {
+ return null;
+ }
+ return DB::eine(
+ 'SELECT t.id AS token_id, t.laeuft_ab_am, t.genutzt_am, n.*
+ FROM sm_token t JOIN sm_nutzer n ON n.id = t.nutzer_id
+ WHERE t.token_hash = ? AND t.art = ? AND t.laeuft_ab_am > ?',
+ [self::hash($token), $art, DB::jetzt()]);
+ }
+
+ public static function tokenLoeschen(int $tokenId): void
+ {
+ DB::ausfuehren('DELETE FROM sm_token WHERE id = ?', [$tokenId]);
+ }
+
+ public static function alleTokenLoeschen(int $nutzerId, string $art): void
+ {
+ DB::ausfuehren('DELETE FROM sm_token WHERE nutzer_id = ? AND art = ?', [$nutzerId, $art]);
+ }
+
+ /**
+ * Prueft das Sitzungstoken des Programms. Wer das Programm regelmaessig
+ * nutzt, bleibt angemeldet: Die Laufzeit verlaengert sich, hoechstens
+ * einmal am Tag geschrieben.
+ */
+ public static function sitzung(string $token): ?array
+ {
+ $zeile = self::tokenFinden($token, 'sitzung');
+ if ($zeile === null || (int) $zeile['gesperrt'] === 1) {
+ return null;
+ }
+ if ($zeile['genutzt_am'] === null || $zeile['genutzt_am'] < DB::jetzt(-86400)) {
+ DB::aktualisieren('sm_token',
+ ['genutzt_am' => DB::jetzt(), 'laeuft_ab_am' => DB::jetzt(self::SITZUNG_TAGE * 86400)],
+ 'id = ?', [$zeile['token_id']]);
+ }
+ return $zeile;
+ }
+
+ public static function passwortRegeln(string $passwort): ?string
+ {
+ if (mb_strlen($passwort) < self::PASSWORT_MIN) {
+ return 'Das Passwort braucht mindestens ' . self::PASSWORT_MIN . ' Zeichen.';
+ }
+ if (strlen($passwort) > 200) {
+ return 'Das Passwort ist zu lang.';
+ }
+ return null;
+ }
+
+ public static function passwortHash(string $passwort): string
+ {
+ return password_hash($passwort, PASSWORD_DEFAULT);
+ }
+
+ public static function ip(): string
+ {
+ return (string) ($_SERVER['REMOTE_ADDR'] ?? '0.0.0.0');
+ }
+
+ /**
+ * Zaehlt Versuche je Art und Schluessel (etwa IP oder E-Mail) im
+ * Zeitfenster. Gibt false zurueck, wenn das Limit erreicht ist - dann
+ * wird auch nichts mehr gezaehlt.
+ */
+ public static function bremse(string $art, string $wer, int $max, int $fensterSekunden): bool
+ {
+ $schluessel = self::hash($art . '|' . $wer);
+ $anzahl = (int) DB::wert(
+ 'SELECT COUNT(*) FROM sm_versuch WHERE art = ? AND schluessel = ? AND zeit > ?',
+ [$art, $schluessel, DB::jetzt(-$fensterSekunden)]);
+ if ($anzahl >= $max) {
+ return false;
+ }
+ DB::einfuegen('sm_versuch', ['art' => $art, 'schluessel' => $schluessel, 'zeit' => DB::jetzt()]);
+ if (random_int(1, 50) === 1) {
+ self::aufraeumen();
+ }
+ return true;
+ }
+
+ public static function bremseLoesen(string $art, string $wer): void
+ {
+ DB::ausfuehren('DELETE FROM sm_versuch WHERE art = ? AND schluessel = ?',
+ [$art, self::hash($art . '|' . $wer)]);
+ }
+
+ public static function bremseOderFehler(string $art, string $wer, int $max, int $fenster): void
+ {
+ if (!self::bremse($art, $wer, $max, $fenster)) {
+ throw new SmFehler('zu_viele_versuche',
+ 'Zu viele Versuche. Bitte warte einige Minuten.', 429);
+ }
+ }
+
+ public static function aufraeumen(): void
+ {
+ DB::ausfuehren('DELETE FROM sm_versuch WHERE zeit < ?', [DB::jetzt(-86400)]);
+ DB::ausfuehren('DELETE FROM sm_token WHERE laeuft_ab_am < ?', [DB::jetzt()]);
+ }
+}
diff --git a/server/sva-privat/app/squads.php b/server/sva-privat/app/squads.php
new file mode 100644
index 0000000..490e3d0
--- /dev/null
+++ b/server/sva-privat/app/squads.php
@@ -0,0 +1,317 @@
+ 48 || preg_match('/[\x00-\x1F\x7F]/u', $name)) {
+ throw new SmFehler('name_ungueltig', 'Der Squadname braucht 3 bis 48 Zeichen.');
+ }
+ return $name;
+ }
+
+ public static function gruenden(array $nutzer, int $charakterId, string $name,
+ string $beschreibung = ''): array
+ {
+ $name = self::name($name);
+ return DB::transaktion(function () use ($nutzer, $charakterId, $name, $beschreibung) {
+ $charakter = self::eigenerCharakter($nutzer, $charakterId);
+ if ($charakter['squad_id'] !== null) {
+ throw new SmFehler('bereits_im_squad', 'Dieser Charakter ist schon in einem Squad.', 409);
+ }
+ if (DB::wert('SELECT 1 FROM sm_squad WHERE name_klein = ?', [mb_strtolower($name)])) {
+ throw new SmFehler('name_vergeben', 'Diesen Squadnamen gibt es schon.', 409);
+ }
+ $id = DB::einfuegen('sm_squad', [
+ 'name' => $name,
+ 'name_klein' => mb_strtolower($name),
+ 'beschreibung' => mb_substr(trim($beschreibung), 0, 2000),
+ 'fuehrer_id' => $charakterId,
+ 'erstellt_am' => DB::jetzt(),
+ ]);
+ DB::aktualisieren('sm_charakter', ['squad_id' => $id, 'squad_seit' => DB::jetzt()],
+ 'id = ?', [$charakterId]);
+ self::hinfaellig($charakterId);
+ return self::details($nutzer, $id);
+ });
+ }
+
+ public static function einladen(array $nutzer, int $squadId, int $charakterId): array
+ {
+ return DB::transaktion(function () use ($nutzer, $squadId, $charakterId) {
+ $squad = self::alsFuehrer($nutzer, $squadId);
+ $ziel = DB::eine('SELECT c.* FROM sm_charakter c JOIN sm_nutzer n ON n.id = c.nutzer_id
+ WHERE c.id = ? AND n.gesperrt = 0' . DB::sperre(), [$charakterId]);
+ if ($ziel === null) {
+ throw new SmFehler('charakter_nicht_gefunden', 'Diesen Charakter gibt es nicht.', 404);
+ }
+ if ($ziel['squad_id'] !== null) {
+ throw new SmFehler('bereits_im_squad', 'Dieser Charakter ist schon in einem Squad.', 409);
+ }
+ if (DB::wert("SELECT 1 FROM sm_einladung WHERE squad_id = ? AND charakter_id = ? AND status = 'offen'",
+ [$squadId, $charakterId])) {
+ throw new SmFehler('schon_eingeladen', 'Dieser Charakter ist schon eingeladen.', 409);
+ }
+ if ((int) DB::wert("SELECT COUNT(*) FROM sm_einladung WHERE squad_id = ? AND status = 'offen'",
+ [$squadId]) >= self::MAX_OFFENE_EINLADUNGEN) {
+ throw new SmFehler('zu_viele_einladungen', 'Zu viele offene Einladungen.', 409);
+ }
+ $id = DB::einfuegen('sm_einladung', [
+ 'squad_id' => $squadId,
+ 'charakter_id' => $charakterId,
+ 'von_charakter_id' => $squad['fuehrer_id'],
+ 'status' => 'offen',
+ 'erstellt_am' => DB::jetzt(),
+ ]);
+ return self::einladungDarstellen(DB::eine('SELECT * FROM sm_einladung WHERE id = ?', [$id]));
+ });
+ }
+
+ private static function charakterKurz(?int $id): ?array
+ {
+ if ($id === null) {
+ return null;
+ }
+ $zeile = DB::eine('SELECT c.id, c.callsign, c.vorname, c.nachname, c.rang, c.status,
+ n.benutzername AS spieler
+ FROM sm_charakter c JOIN sm_nutzer n ON n.id = c.nutzer_id WHERE c.id = ?', [$id]);
+ return $zeile === null ? null : ['id' => (int) $zeile['id']] + $zeile;
+ }
+
+ private static function einladungDarstellen(array $zeile): array
+ {
+ $squad = DB::eine('SELECT id, name FROM sm_squad WHERE id = ?', [$zeile['squad_id']]);
+ return [
+ 'id' => (int) $zeile['id'],
+ 'status' => $zeile['status'],
+ 'erstellt_am' => $zeile['erstellt_am'],
+ 'squad' => $squad === null ? null : ['id' => (int) $squad['id'], 'name' => $squad['name']],
+ 'charakter' => self::charakterKurz((int) $zeile['charakter_id']),
+ 'von' => self::charakterKurz($zeile['von_charakter_id'] === null ? null : (int) $zeile['von_charakter_id']),
+ ];
+ }
+
+ /** Offene Einladungen an eigene Charaktere und von eigenen Squads. */
+ public static function einladungen(array $nutzer): array
+ {
+ $eingang = DB::alle("SELECT e.* FROM sm_einladung e JOIN sm_charakter c ON c.id = e.charakter_id
+ WHERE c.nutzer_id = ? AND e.status = 'offen' ORDER BY e.erstellt_am", [$nutzer['id']]);
+ $ausgang = DB::alle("SELECT e.* FROM sm_einladung e
+ JOIN sm_squad s ON s.id = e.squad_id
+ JOIN sm_charakter f ON f.id = s.fuehrer_id
+ WHERE f.nutzer_id = ? AND e.status = 'offen' ORDER BY e.erstellt_am", [$nutzer['id']]);
+ return [
+ 'eingang' => array_map([self::class, 'einladungDarstellen'], $eingang),
+ 'ausgang' => array_map([self::class, 'einladungDarstellen'], $ausgang),
+ ];
+ }
+
+ private static function einladungMitSperre(int $einladungId): array
+ {
+ $einladung = DB::eine('SELECT * FROM sm_einladung WHERE id = ?' . DB::sperre(), [$einladungId]);
+ if ($einladung === null || $einladung['status'] !== 'offen') {
+ throw new SmFehler('einladung_nicht_offen', 'Diese Einladung ist nicht mehr offen.', 409);
+ }
+ return $einladung;
+ }
+
+ public static function beantworten(array $nutzer, int $einladungId, bool $annehmen): void
+ {
+ DB::transaktion(function () use ($nutzer, $einladungId, $annehmen) {
+ $einladung = self::einladungMitSperre($einladungId);
+ $charakter = self::eigenerCharakter($nutzer, (int) $einladung['charakter_id']);
+ if ($annehmen) {
+ if ($charakter['squad_id'] !== null) {
+ throw new SmFehler('bereits_im_squad',
+ 'Dieser Charakter ist schon in einem Squad. Verlasse es zuerst.', 409);
+ }
+ self::squadMitSperre((int) $einladung['squad_id']);
+ DB::aktualisieren('sm_charakter',
+ ['squad_id' => $einladung['squad_id'], 'squad_seit' => DB::jetzt()],
+ 'id = ?', [$charakter['id']]);
+ }
+ DB::aktualisieren('sm_einladung',
+ ['status' => $annehmen ? 'angenommen' : 'abgelehnt', 'beantwortet_am' => DB::jetzt()],
+ 'id = ?', [$einladungId]);
+ if ($annehmen) {
+ self::hinfaellig((int) $charakter['id']);
+ }
+ });
+ }
+
+ /** Weitere offene Einladungen eines Charakters, der gerade einem Squad beigetreten ist. */
+ private static function hinfaellig(int $charakterId): void
+ {
+ DB::ausfuehren("UPDATE sm_einladung SET status = 'hinfaellig', beantwortet_am = ?
+ WHERE charakter_id = ? AND status = 'offen'", [DB::jetzt(), $charakterId]);
+ }
+
+ public static function zurueckziehen(array $nutzer, int $einladungId): void
+ {
+ DB::transaktion(function () use ($nutzer, $einladungId) {
+ $einladung = self::einladungMitSperre($einladungId);
+ self::alsFuehrer($nutzer, (int) $einladung['squad_id']);
+ DB::aktualisieren('sm_einladung', ['status' => 'zurueckgezogen', 'beantwortet_am' => DB::jetzt()],
+ 'id = ?', [$einladungId]);
+ });
+ }
+
+ public static function verlassen(array $nutzer, int $charakterId): void
+ {
+ DB::transaktion(function () use ($nutzer, $charakterId) {
+ $charakter = self::eigenerCharakter($nutzer, $charakterId);
+ if ($charakter['squad_id'] === null) {
+ throw new SmFehler('nicht_im_squad', 'Dieser Charakter ist in keinem Squad.', 409);
+ }
+ $squad = self::squadMitSperre((int) $charakter['squad_id']);
+ if ((int) $squad['fuehrer_id'] === $charakterId) {
+ $weitere = (int) DB::wert('SELECT COUNT(*) FROM sm_charakter WHERE squad_id = ? AND id <> ?',
+ [$squad['id'], $charakterId]);
+ if ($weitere > 0) {
+ throw new SmFehler('fuehrer_muss_uebergeben',
+ 'Als Squadführer musst du zuerst die Führung übergeben oder das Squad auflösen.', 409);
+ }
+ self::aufloesenIntern((int) $squad['id']);
+ return;
+ }
+ DB::aktualisieren('sm_charakter', ['squad_id' => null, 'squad_seit' => null], 'id = ?', [$charakterId]);
+ });
+ }
+
+ public static function entfernen(array $nutzer, int $squadId, int $charakterId): void
+ {
+ DB::transaktion(function () use ($nutzer, $squadId, $charakterId) {
+ $squad = self::alsFuehrer($nutzer, $squadId);
+ if ((int) $squad['fuehrer_id'] === $charakterId) {
+ throw new SmFehler('fuehrer', 'Der Squadführer kann sich nicht selbst entfernen.', 409);
+ }
+ $anzahl = DB::aktualisieren('sm_charakter', ['squad_id' => null, 'squad_seit' => null],
+ 'id = ? AND squad_id = ?', [$charakterId, $squadId]);
+ if ($anzahl === 0) {
+ throw new SmFehler('nicht_im_squad', 'Dieser Charakter ist nicht in deinem Squad.', 409);
+ }
+ });
+ }
+
+ public static function fuehrungUebergeben(array $nutzer, int $squadId, int $charakterId): void
+ {
+ DB::transaktion(function () use ($nutzer, $squadId, $charakterId) {
+ self::alsFuehrer($nutzer, $squadId);
+ if (!DB::wert('SELECT 1 FROM sm_charakter WHERE id = ? AND squad_id = ?', [$charakterId, $squadId])) {
+ throw new SmFehler('nicht_im_squad', 'Dieser Charakter ist nicht in deinem Squad.', 409);
+ }
+ DB::aktualisieren('sm_squad', ['fuehrer_id' => $charakterId], 'id = ?', [$squadId]);
+ });
+ }
+
+ public static function aufloesen(array $nutzer, int $squadId): void
+ {
+ DB::transaktion(function () use ($nutzer, $squadId) {
+ self::alsFuehrer($nutzer, $squadId);
+ self::aufloesenIntern($squadId);
+ });
+ }
+
+ /** Fuer die Verwaltung. */
+ public static function aufloesenNachId(int $squadId): void
+ {
+ DB::transaktion(fn() => self::aufloesenIntern($squadId));
+ }
+
+ private static function aufloesenIntern(int $squadId): void
+ {
+ DB::ausfuehren('UPDATE sm_charakter SET squad_id = NULL, squad_seit = NULL WHERE squad_id = ?', [$squadId]);
+ DB::ausfuehren('DELETE FROM sm_einladung WHERE squad_id = ?', [$squadId]);
+ DB::ausfuehren('DELETE FROM sm_squad WHERE id = ?', [$squadId]);
+ }
+
+ /**
+ * Ein Charakter wird geloescht. Fuehrt er ein Squad, uebernimmt das
+ * dienstaelteste Mitglied; ist er allein, wird das Squad aufgeloest.
+ */
+ public static function beimLoeschen(array $charakter): void
+ {
+ if ($charakter['squad_id'] === null) {
+ return;
+ }
+ $squad = DB::eine('SELECT * FROM sm_squad WHERE id = ?' . DB::sperre(), [$charakter['squad_id']]);
+ if ($squad === null || (int) $squad['fuehrer_id'] !== (int) $charakter['id']) {
+ return;
+ }
+ $nachfolger = DB::wert('SELECT id FROM sm_charakter WHERE squad_id = ? AND id <> ?
+ ORDER BY squad_seit, id LIMIT 1', [$squad['id'], $charakter['id']]);
+ if ($nachfolger === null) {
+ self::aufloesenIntern((int) $squad['id']);
+ } else {
+ DB::aktualisieren('sm_squad', ['fuehrer_id' => (int) $nachfolger], 'id = ?', [$squad['id']]);
+ }
+ }
+
+ public static function details(array $nutzer, int $squadId): array
+ {
+ $squad = DB::eine('SELECT * FROM sm_squad WHERE id = ?', [$squadId]);
+ if ($squad === null) {
+ throw new SmFehler('squad_nicht_gefunden', 'Dieses Squad gibt es nicht mehr.', 404);
+ }
+ $mitglieder = DB::alle('SELECT c.*, n.benutzername AS spieler
+ FROM sm_charakter c JOIN sm_nutzer n ON n.id = c.nutzer_id
+ WHERE c.squad_id = ? ORDER BY c.squad_seit, c.id', [$squadId]);
+ return [
+ 'id' => (int) $squad['id'],
+ 'name' => $squad['name'],
+ 'beschreibung' => (string) $squad['beschreibung'],
+ 'fuehrer_id' => (int) $squad['fuehrer_id'],
+ 'erstellt_am' => $squad['erstellt_am'],
+ 'mitglieder' => array_map(fn($zeile) => Charaktere::zusammenfassung($zeile, $nutzer), $mitglieder),
+ ];
+ }
+
+ public static function liste(array $nutzer): array
+ {
+ $ids = DB::alle('SELECT id FROM sm_squad ORDER BY name');
+ return array_map(fn($zeile) => self::details($nutzer, (int) $zeile['id']), $ids);
+ }
+}
diff --git a/server/sva-privat/app/start.php b/server/sva-privat/app/start.php
new file mode 100644
index 0000000..978d7a1
--- /dev/null
+++ b/server/sva-privat/app/start.php
@@ -0,0 +1,75 @@
+ 0,
+ 'path' => '/verwaltung/',
+ 'secure' => str_starts_with((string) sm_config('basis_url', ''), 'https://'),
+ 'httponly' => true,
+ 'samesite' => 'Strict',
+ ]);
+ session_start();
+ }
+
+ /** Angemeldeter Admin oder null. Ein geaendertes Passwort beendet die Sitzung. */
+ public static function admin(): ?array
+ {
+ $id = $_SESSION['admin_id'] ?? null;
+ if (!is_int($id) || (time() - (int) ($_SESSION['zuletzt'] ?? 0)) > self::LEERLAUF) {
+ return null;
+ }
+ $nutzer = DB::eine("SELECT * FROM sm_nutzer WHERE id = ? AND rolle = 'admin' AND gesperrt = 0", [$id]);
+ if ($nutzer === null || !hash_equals((string) ($_SESSION['fingerabdruck'] ?? ''),
+ hash('sha256', (string) $nutzer['passwort_hash']))) {
+ return null;
+ }
+ $_SESSION['zuletzt'] = time();
+ return $nutzer;
+ }
+
+ public static function csrf(): string
+ {
+ if (empty($_SESSION['csrf'])) {
+ $_SESSION['csrf'] = Sicherheit::zufall(24);
+ }
+ return $_SESSION['csrf'];
+ }
+
+ public static function csrfFeld(): string
+ {
+ return ' ';
+ }
+
+ private static function csrfPruefen(): void
+ {
+ if (!hash_equals(self::csrf(), (string) ($_POST['csrf'] ?? ''))) {
+ throw new SmFehler('csrf', 'Die Sitzung ist abgelaufen. Bitte lade die Seite neu.', 400);
+ }
+ }
+
+ private static function weiter(string $seite, string $meldung = '', string $art = 'info'): never
+ {
+ if ($meldung !== '') {
+ $_SESSION['meldung'] = [$meldung, $art];
+ }
+ header('Location: ./?seite=' . rawurlencode($seite), true, 303);
+ exit;
+ }
+
+ private static function meldung(): string
+ {
+ [$text, $art] = $_SESSION['meldung'] ?? ['', 'info'];
+ unset($_SESSION['meldung']);
+ return $text === '' ? '' : Web::hinweis(Web::e($text), $art);
+ }
+
+ // -- Ablauf -------------------------------------------------------------
+
+ public static function behandeln(): never
+ {
+ self::starten();
+ $seite = (string) ($_GET['seite'] ?? 'uebersicht');
+ try {
+ $admin = self::admin();
+ if ($admin === null) {
+ self::anmeldung();
+ }
+ if ($_SERVER['REQUEST_METHOD'] === 'POST') {
+ self::csrfPruefen();
+ self::aktion($admin, (string) ($_POST['aktion'] ?? ''));
+ }
+ match ($seite) {
+ 'nutzer' => self::seiteNutzer(),
+ 'charaktere' => self::seiteCharaktere(),
+ 'charakter' => self::seiteCharakter((int) ($_GET['id'] ?? 0)),
+ 'squads' => self::seiteSquads(),
+ 'bestaetigen' => self::seiteBestaetigen(),
+ 'bild' => self::bild((int) ($_GET['id'] ?? 0)),
+ default => self::seiteUebersicht(),
+ };
+ } catch (SmFehler $fehler) {
+ Web::seite('Verwaltung', Web::hinweis(Web::e($fehler->getMessage()), 'fehler')
+ . 'Zur Übersicht
');
+ }
+ }
+
+ private static function anmeldung(): never
+ {
+ $fehler = '';
+ if ($_SERVER['REQUEST_METHOD'] === 'POST' && ($_POST['aktion'] ?? '') === 'anmelden') {
+ try {
+ self::csrfPruefen();
+ $email = mb_strtolower(trim((string) ($_POST['email'] ?? '')));
+ Sicherheit::bremseOderFehler('verwaltung', Sicherheit::ip(), 8, 900);
+ $nutzer = DB::eine("SELECT * FROM sm_nutzer WHERE email = ? AND rolle = 'admin' AND gesperrt = 0", [$email]);
+ $hash = $nutzer['passwort_hash'] ?? null;
+ if ($hash === null || !password_verify((string) ($_POST['passwort'] ?? ''), $hash)) {
+ throw new SmFehler('anmeldung_falsch', 'E-Mail oder Passwort stimmt nicht.');
+ }
+ Sicherheit::bremseLoesen('verwaltung', Sicherheit::ip());
+ session_regenerate_id(true);
+ $_SESSION['admin_id'] = (int) $nutzer['id'];
+ $_SESSION['zuletzt'] = time();
+ $_SESSION['fingerabdruck'] = hash('sha256', $hash);
+ DB::aktualisieren('sm_nutzer', ['letzte_anmeldung_am' => DB::jetzt()], 'id = ?', [$nutzer['id']]);
+ self::weiter('uebersicht');
+ } catch (SmFehler $f) {
+ $fehler = Web::hinweis(Web::e($f->getMessage()), 'fehler');
+ }
+ }
+ Web::seite('Verwaltung', '');
+ }
+
+ private static function aktion(array $admin, string $aktion): never
+ {
+ $id = (int) ($_POST['id'] ?? 0);
+ switch ($aktion) {
+ case 'abmelden':
+ $_SESSION = [];
+ session_destroy();
+ header('Location: ./', true, 303);
+ exit;
+ case 'nutzer_sperren':
+ case 'nutzer_entsperren':
+ self::nichtSelbst($admin, $id);
+ DB::aktualisieren('sm_nutzer', ['gesperrt' => $aktion === 'nutzer_sperren' ? 1 : 0], 'id = ?', [$id]);
+ if ($aktion === 'nutzer_sperren') {
+ Sicherheit::alleTokenLoeschen($id, 'sitzung');
+ }
+ self::weiter('nutzer', $aktion === 'nutzer_sperren' ? 'Nutzer gesperrt und abgemeldet.' : 'Nutzer entsperrt.');
+ case 'nutzer_bestaetigen':
+ DB::aktualisieren('sm_nutzer', ['email_bestaetigt_am' => DB::jetzt()],
+ 'id = ? AND email_bestaetigt_am IS NULL', [$id]);
+ self::weiter('nutzer', 'E-Mail-Adresse als bestätigt markiert.');
+ case 'nutzer_passwortlink':
+ $nutzer = DB::eine('SELECT * FROM sm_nutzer WHERE id = ?', [$id]);
+ if ($nutzer !== null) {
+ Konten::passwortLinkSenden($nutzer, 86400,
+ "über die Verwaltung wurde ein Link zum Festlegen eines neuen Passworts angefordert:\n\n"
+ . "%LINK%\n\nDer Link ist 24 Stunden gültig.");
+ }
+ self::weiter('nutzer', 'Link zum Passwort-Festlegen verschickt.');
+ case 'nutzer_loeschen':
+ self::nichtSelbst($admin, $id);
+ Konten::loeschen($id);
+ self::weiter('nutzer', 'Nutzer samt Charakteren gelöscht.');
+ case 'charakter_loeschen':
+ Charaktere::loeschenNachId($id);
+ self::weiter('charaktere', 'Charakter gelöscht.');
+ case 'squad_aufloesen':
+ Squads::aufloesenNachId($id);
+ self::weiter('squads', 'Squad aufgelöst.');
+ }
+ throw new SmFehler('aktion_unbekannt', 'Unbekannte Aktion.');
+ }
+
+ private static function nichtSelbst(array $admin, int $id): void
+ {
+ if ((int) $admin['id'] === $id) {
+ throw new SmFehler('selbst', 'Den eigenen Verwaltungszugang kannst du nicht sperren oder löschen.');
+ }
+ }
+
+ // -- Seiten -------------------------------------------------------------
+
+ private static function navigation(string $aktiv): string
+ {
+ $punkte = ['uebersicht' => 'ÜBERSICHT', 'nutzer' => 'NUTZER', 'charaktere' => 'CHARAKTERE', 'squads' => 'SQUADS'];
+ $html = '';
+ foreach ($punkte as $seite => $text) {
+ $html .= '$text ";
+ }
+ return $html . ' ';
+ }
+
+ private static function knopf(string $aktion, int $id, string $text, bool $gefahr = false): string
+ {
+ return ' ';
+ }
+
+ /** Loeschen und Aufloesen ueber eine eigene Seite statt ueber JavaScript-Rueckfragen. */
+ private static function loeschLink(string $aktion, int $id, string $text): string
+ {
+ return ''
+ . Web::e($text) . ' ';
+ }
+
+ private static function datum(?string $wert): string
+ {
+ return $wert === null ? '— ' : Web::e(substr($wert, 0, 16)) . ' UTC ';
+ }
+
+ private static function suchfeld(string $seite): array
+ {
+ $suche = trim(mb_substr((string) ($_GET['q'] ?? ''), 0, 64));
+ $html = '';
+ $muster = '%' . str_replace(['!', '%', '_'], ['!!', '!%', '!_'], $suche) . '%';
+ return [$suche, $muster, $html];
+ }
+
+ private static function seiteUebersicht(): never
+ {
+ $zahlen = [
+ 'Nutzer' => DB::wert('SELECT COUNT(*) FROM sm_nutzer'),
+ 'Unbestätigt' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE email_bestaetigt_am IS NULL'),
+ 'Gesperrt' => DB::wert('SELECT COUNT(*) FROM sm_nutzer WHERE gesperrt = 1'),
+ 'Charaktere' => DB::wert('SELECT COUNT(*) FROM sm_charakter'),
+ 'Squads' => DB::wert('SELECT COUNT(*) FROM sm_squad'),
+ 'Offene Einladungen' => DB::wert("SELECT COUNT(*) FROM sm_einladung WHERE status = 'offen'"),
+ ];
+ $html = self::meldung() . 'Übersicht ';
+ foreach ($zahlen as $text => $wert) {
+ $html .= '
' . (int) $wert . ' ' . Web::e($text) . '
';
+ }
+ $html .= '
NEUESTE KONTEN Benutzername E-Mail Registriert ';
+ foreach (DB::alle('SELECT benutzername, email, erstellt_am FROM sm_nutzer ORDER BY id DESC LIMIT 10') as $n) {
+ $html .= '' . Web::e($n['benutzername']) . ' ' . Web::e($n['email']) . ' '
+ . self::datum($n['erstellt_am']) . ' ';
+ }
+ Web::seite('Verwaltung', $html . '
', '1100px', self::navigation('uebersicht'));
+ }
+
+ private static function seiteNutzer(): never
+ {
+ [$suche, $muster, $suchHtml] = self::suchfeld('nutzer');
+ $sql = 'SELECT n.*, (SELECT COUNT(*) FROM sm_charakter c WHERE c.nutzer_id = n.id) AS anzahl FROM sm_nutzer n';
+ $werte = [];
+ if ($suche !== '') {
+ $sql .= " WHERE n.benutzername LIKE ? ESCAPE '!' OR n.email LIKE ? ESCAPE '!'";
+ $werte = [$muster, $muster];
+ }
+ $zeilen = DB::alle($sql . ' ORDER BY n.id DESC LIMIT 300', $werte);
+ $html = self::meldung() . 'Nutzer ' . $suchHtml
+ . 'Benutzername E-Mail Rolle Bestätigt '
+ . 'Charaktere Registriert Letzte Anmeldung ';
+ foreach ($zeilen as $n) {
+ $id = (int) $n['id'];
+ $gesperrt = (int) $n['gesperrt'] === 1;
+ $aktionen = $gesperrt ? self::knopf('nutzer_entsperren', $id, 'Entsperren')
+ : self::knopf('nutzer_sperren', $id, 'Sperren', true);
+ if ($n['email_bestaetigt_am'] === null) {
+ $aktionen .= self::knopf('nutzer_bestaetigen', $id, 'Bestätigen');
+ }
+ $aktionen .= self::knopf('nutzer_passwortlink', $id, 'Passwort-Link');
+ if ($n['rolle'] !== 'admin') {
+ $aktionen .= self::loeschLink('nutzer_loeschen', $id, 'Löschen …');
+ }
+ $html .= '' . Web::e($n['benutzername']) . ($gesperrt ? ' gesperrt ' : '')
+ . ' ' . Web::e($n['email']) . ' ' . Web::e($n['rolle']) . ' '
+ . ($n['email_bestaetigt_am'] === null ? 'nein ' : 'ja')
+ . ' ' . (int) $n['anzahl'] . ' ' . self::datum($n['erstellt_am'])
+ . ' ' . self::datum($n['letzte_anmeldung_am']) . ' ' . $aktionen . ' ';
+ }
+ Web::seite('Verwaltung', $html . '
', '1300px', self::navigation('nutzer'));
+ }
+
+ private static function seiteCharaktere(): never
+ {
+ [$suche, $muster, $suchHtml] = self::suchfeld('charaktere');
+ $sql = 'SELECT c.*, n.benutzername AS spieler, s.name AS squad FROM sm_charakter c
+ JOIN sm_nutzer n ON n.id = c.nutzer_id LEFT JOIN sm_squad s ON s.id = c.squad_id';
+ $werte = [];
+ if ($suche !== '') {
+ $sql .= " WHERE c.callsign LIKE ? ESCAPE '!' OR c.nachname LIKE ? ESCAPE '!' OR c.vorname LIKE ? ESCAPE '!'"
+ . " OR n.benutzername LIKE ? ESCAPE '!' OR c.aktennummer LIKE ? ESCAPE '!'";
+ $werte = array_fill(0, 5, $muster);
+ }
+ $zeilen = DB::alle($sql . ' ORDER BY c.geaendert_am DESC LIMIT 300', $werte);
+ $html = self::meldung() . 'Charaktere ' . $suchHtml
+ . 'Akte Callsign Name Dienstgrad '
+ . 'Fraktion Status Spieler Squad Geändert ';
+ foreach ($zeilen as $c) {
+ $id = (int) $c['id'];
+ $html .= '' . Web::e($c['aktennummer']) . ' ' . Web::e($c['callsign'])
+ . ' ' . Web::e(trim($c['vorname'] . ' ' . $c['nachname'])) . ' ' . Web::e($c['rang'])
+ . ' ' . Web::e(trim($c['fraktion'] . ($c['teilstreitkraft'] ? ' · ' . $c['teilstreitkraft'] : '')))
+ . ' ' . Web::e($c['status']) . ' ' . Web::e($c['spieler']) . ' '
+ . Web::e($c['squad'] ?? '—') . ' ' . self::datum($c['geaendert_am']) . ' '
+ . 'Ansehen · '
+ . self::loeschLink('charakter_loeschen', $id, 'Löschen …') . ' ';
+ }
+ Web::seite('Verwaltung', $html . '
', '1300px', self::navigation('charaktere'));
+ }
+
+ private static function seiteCharakter(int $id): never
+ {
+ $c = DB::eine('SELECT c.*, n.benutzername AS spieler, n.email FROM sm_charakter c
+ JOIN sm_nutzer n ON n.id = c.nutzer_id WHERE c.id = ?', [$id]);
+ if ($c === null) {
+ throw new SmFehler('nicht_gefunden', 'Diesen Charakter gibt es nicht.');
+ }
+ $daten = json_encode(json_decode($c['daten'], true), JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
+ $bild = $c['portraet'] !== null
+ ? ' '
+ : '';
+ $html = '' . Web::e($c['callsign'] ?: trim($c['vorname'] . ' ' . $c['nachname'])) . ' '
+ . $bild . '
' . Web::e($c['aktennummer']) . '
' . Web::e(trim($c['rang'] . ' '
+ . $c['vorname'] . ' ' . $c['nachname'])) . ' ' . Web::e($c['fraktion']) . ' · ' . Web::e($c['teilstreitkraft'])
+ . ' Status: ' . Web::e($c['status']) . '
Spieler: ' . Web::e($c['spieler']) . ' (' . Web::e($c['email'])
+ . ') Version ' . (int) $c['version'] . ', geändert ' . self::datum($c['geaendert_am']) . '
'
+ . '
' . self::loeschLink('charakter_loeschen', $id, 'Charakter löschen …') . '
'
+ . '
AKTE (ROHDATEN) ' . Web::e($daten) . ' ';
+ Web::seite('Verwaltung', $html, '900px', self::navigation('charaktere'));
+ }
+
+ private static function seiteSquads(): never
+ {
+ $html = self::meldung() . 'Squads Name Führer '
+ . 'Mitglieder Gegründet ';
+ foreach (DB::alle('SELECT * FROM sm_squad ORDER BY name') as $s) {
+ $mitglieder = DB::alle('SELECT id, callsign, nachname FROM sm_charakter WHERE squad_id = ? ORDER BY squad_seit', [$s['id']]);
+ $namen = array_map(fn($m) => ((int) $m['id'] === (int) $s['fuehrer_id'] ? '★ ' : '')
+ . Web::e($m['callsign'] ?: $m['nachname']), $mitglieder);
+ $fuehrer = array_values(array_filter($mitglieder, fn($m) => (int) $m['id'] === (int) $s['fuehrer_id']));
+ $html .= '' . Web::e($s['name']) . ' ' . Web::e($fuehrer[0]['callsign'] ?? '—') . ' '
+ . implode(', ', $namen) . ' ' . self::datum($s['erstellt_am']) . ' '
+ . self::loeschLink('squad_aufloesen', (int) $s['id'], 'Auflösen …') . ' ';
+ }
+ Web::seite('Verwaltung', $html . '
', '1100px', self::navigation('squads'));
+ }
+
+ private static function seiteBestaetigen(): never
+ {
+ $aktion = (string) ($_GET['aktion'] ?? '');
+ $id = (int) ($_GET['id'] ?? 0);
+ $texte = [
+ 'nutzer_loeschen' => ['nutzer', 'Nutzer endgültig löschen? Alle seine Charaktere werden mitgelöscht.',
+ fn() => DB::wert('SELECT benutzername FROM sm_nutzer WHERE id = ?', [$id])],
+ 'charakter_loeschen' => ['charaktere', 'Charakter endgültig löschen? Führt er ein Squad, übernimmt das dienstälteste Mitglied.',
+ fn() => DB::wert("SELECT COALESCE(NULLIF(callsign, ''), nachname) FROM sm_charakter WHERE id = ?", [$id])],
+ 'squad_aufloesen' => ['squads', 'Squad auflösen? Die Mitglieder bleiben erhalten, sind danach aber ohne Squad.',
+ fn() => DB::wert('SELECT name FROM sm_squad WHERE id = ?', [$id])],
+ ];
+ if (!isset($texte[$aktion])) {
+ throw new SmFehler('aktion_unbekannt', 'Unbekannte Aktion.');
+ }
+ [$zurueck, $frage, $name] = $texte[$aktion];
+ $html = 'Bestätigen ' . Web::e($name() ?? '?') . '
' . Web::e($frage) . '
'
+ . '
';
+ Web::seite('Verwaltung', $html, '560px', self::navigation($zurueck));
+ }
+
+ private static function bild(int $id): never
+ {
+ $pfad = Charaktere::bildPfad($id);
+ if ($pfad === null) {
+ http_response_code(404);
+ exit;
+ }
+ header('Content-Type: image/png');
+ header('X-Content-Type-Options: nosniff');
+ header('Cache-Control: private, max-age=300');
+ readfile($pfad);
+ exit;
+ }
+}
diff --git a/server/sva-privat/app/web.php b/server/sva-privat/app/web.php
new file mode 100644
index 0000000..f3f75fd
--- /dev/null
+++ b/server/sva-privat/app/web.php
@@ -0,0 +1,110 @@
+' . $text . '
';
+ }
+
+ public static function seite(string $titel, string $inhalt, string $breite = '560px', string $navigation = ''): never
+ {
+ self::sicherheitskoepfe();
+ $titelE = self::e($titel);
+ $rechtliches = self::e(sm_config('rechtliches_url', 'https://tyrveil.com/rechtliches#impressum'));
+ echo <<
+
+
+
+
+
+$titelE – Squad Manager
+
+
+
+
+
+ SQUAD MANAGER $titelE
+ $navigation
+ $inhalt
+
+
+
+
+HTML;
+ exit;
+ }
+}
diff --git a/server/sva-privat/config.beispiel.php b/server/sva-privat/config.beispiel.php
new file mode 100644
index 0000000..bfcd600
--- /dev/null
+++ b/server/sva-privat/config.beispiel.php
@@ -0,0 +1,46 @@
+ [
+ // Plesk: Datenbank und Benutzer heissen 214729_sva
+ 'dsn' => 'mysql:host=localhost;dbname=214729_sva;charset=utf8mb4',
+ 'benutzer' => '214729_sva',
+ 'passwort' => '', // HIER das Datenbank-Passwort aus Plesk eintragen
+ ],
+
+ 'basis_url' => 'https://sva.tyrveil.com',
+ 'rechtliches_url' => 'https://tyrveil.com/rechtliches#impressum',
+
+ // Diese Adresse bekommt beim Einrichten den Verwaltungszugang
+ 'admin_email' => 'info@tyrveil.com',
+
+ 'mail' => [
+ // php_mail: ueber den Mailserver von Plesk, kein Passwort noetig
+ // smtp: ueber ein Postfach, dann unten Zugang eintragen
+ // datei: nur fuer Tests, schreibt Mails nach daten/mails
+ 'art' => 'php_mail',
+ 'absender' => 'info@tyrveil.com',
+ 'absender_name' => 'Squad Manager',
+ 'smtp' => [
+ 'host' => 'localhost',
+ 'port' => 587,
+ 'verschluesselung' => 'tls', // tls, ssl oder keine
+ 'benutzer' => '',
+ 'passwort' => '',
+ ],
+ ],
+
+ // Einmaliger Schluessel fuer einrichten.php. Vor dem Einrichten eine
+ // lange Zufallszeichenkette eintragen (mindestens 24 Zeichen), danach
+ // wieder leeren - dann ist einrichten.php abgeschaltet.
+ 'einrichtungs_schluessel' => '',
+
+ 'daten_ordner' => __DIR__ . '/daten',
+ 'fehler_anzeigen' => false,
+];
diff --git a/server/sva.tyrveil.com/api/bild.php b/server/sva.tyrveil.com/api/bild.php
new file mode 100644
index 0000000..fa599d2
--- /dev/null
+++ b/server/sva.tyrveil.com/api/bild.php
@@ -0,0 +1,24 @@
+Einrichtung abgeschaltet '
+ . 'Zum Einrichten in sva-privat/config.php einen '
+ . 'einrichtungs_schluessel mit mindestens 24 Zeichen eintragen.
');
+}
+
+$form = '';
+
+if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
+ Web::seite('Einrichtung', '
Einrichtung ' . $form . '');
+}
+if (!hash_equals($schluessel, (string) ($_POST['schluessel'] ?? ''))) {
+ sleep(2);
+ Web::seite('Einrichtung', '
Einrichtung '
+ . Web::hinweis('Der Schlüssel stimmt nicht.', 'fehler') . $form . '');
+}
+
+$zeilen = [];
+$ok = true;
+$pruefen = function (string $text, bool $bestanden, string $hilfe = '') use (&$zeilen, &$ok) {
+ $ok = $ok && $bestanden;
+ $zeilen[] = '' . ($bestanden ? '✓' : '✗ ') . ' ' . Web::e($text)
+ . ($bestanden || $hilfe === '' ? '' : '' . Web::e($hilfe) . ' ') . ' ';
+};
+
+$pruefen('PHP ' . PHP_VERSION, version_compare(PHP_VERSION, '8.1', '>='), 'Mindestens PHP 8.1 nötig.');
+$treiber = DB::sqlite() ? 'pdo_sqlite' : 'pdo_mysql';
+$pruefen("Erweiterung $treiber", extension_loaded($treiber), 'In Plesk unter PHP-Einstellungen aktivieren.');
+$pruefen('Erweiterung gd (Porträts)', extension_loaded('gd'), 'In Plesk unter PHP-Einstellungen aktivieren.');
+$pruefen('Erweiterung mbstring', extension_loaded('mbstring'), 'In Plesk unter PHP-Einstellungen aktivieren.');
+$pruefen('Datenordner beschreibbar', is_writable(sm_daten_ordner()) && is_writable(sm_daten_ordner('portraets')),
+ 'Der Ordner sva-privat/daten muss für PHP beschreibbar sein.');
+
+$adminHinweis = '';
+if ($ok) {
+ try {
+ $tabellen = DB::schemaAnlegen();
+ $pruefen('Datenbank: ' . count($tabellen) . ' Tabellen vorhanden', true);
+
+ $email = mb_strtolower((string) sm_config('admin_email', 'info@tyrveil.com'));
+ $admin = DB::eine('SELECT * FROM sm_nutzer WHERE email = ?', [$email]);
+ if ($admin === null) {
+ $name = DB::wert("SELECT 1 FROM sm_nutzer WHERE benutzername_klein = 'admin'") ? 'Admin-' . random_int(100, 999) : 'Admin';
+ DB::einfuegen('sm_nutzer', [
+ 'benutzername' => $name, 'benutzername_klein' => mb_strtolower($name), 'email' => $email,
+ 'passwort_hash' => null, 'rolle' => 'admin', 'email_bestaetigt_am' => DB::jetzt(),
+ 'gesperrt' => 0, 'erstellt_am' => DB::jetzt(),
+ ]);
+ $admin = DB::eine('SELECT * FROM sm_nutzer WHERE email = ?', [$email]);
+ $pruefen("Verwaltungszugang für $email angelegt", true);
+ } else {
+ DB::aktualisieren('sm_nutzer', ['rolle' => 'admin', 'gesperrt' => 0], 'id = ?', [$admin['id']]);
+ $pruefen("Verwaltungszugang für $email vorhanden", true);
+ }
+
+ if ($admin['passwort_hash'] === null) {
+ $link = Konten::passwortLinkSenden($admin, 7 * 86400,
+ "der Verwaltungszugang für sva.tyrveil.com ist eingerichtet. Lege hier dein Passwort fest:\n\n"
+ . "%LINK%\n\nDer Link ist sieben Tage gültig.");
+ $adminHinweis = Web::hinweis('Eine Mail mit dem Link zum Passwort-Festlegen ging an ' . Web::e($email)
+ . ' . Es gilt nur der zuletzt verschickte Link. Falls die Mail nicht ankommt, kannst du ihn auch direkt hier öffnen: '
+ . 'Passwort jetzt festlegen ', 'warnung');
+ } else {
+ $adminHinweis = Web::hinweis('Der Verwaltungszugang hat schon ein Passwort. Vergessen? '
+ . 'Neues anfordern ');
+ }
+ } catch (Throwable $fehler) {
+ sm_log('Einrichtung: ' . $fehler->getMessage());
+ $pruefen('Datenbankverbindung', false, $fehler instanceof PDOException
+ ? 'Zugangsdaten in config.php prüfen. Meldung: ' . $fehler->getMessage()
+ : $fehler->getMessage());
+ }
+}
+
+Web::seite('Einrichtung', 'Einrichtung ' . implode('', $zeilen) . '
'
+ . $adminHinweis
+ . ($ok ? Web::hinweis('Fertig. Trage in config.php den '
+ . 'einrichtungs_schluessel wieder leer ein – damit ist diese Seite abgeschaltet.', 'warnung')
+ : Web::hinweis('Die Einrichtung ist noch nicht abgeschlossen. Behebe die markierten Punkte und lade die Seite erneut.', 'fehler')));
diff --git a/server/sva.tyrveil.com/konto/bestaetigen.php b/server/sva.tyrveil.com/konto/bestaetigen.php
new file mode 100644
index 0000000..4f1217d
--- /dev/null
+++ b/server/sva.tyrveil.com/konto/bestaetigen.php
@@ -0,0 +1,14 @@
+E-Mail bestätigt '
+ . 'Danke, ' . Web::e($nutzer['benutzername']) . '. Deine Adresse ist bestätigt.
'
+ . 'Du kannst dich jetzt im Squad Manager anmelden.
');
+} catch (SmFehler $fehler) {
+ Web::seite('E-Mail bestätigen', 'Link ungültig '
+ . Web::hinweis(Web::e($fehler->getMessage()), 'fehler')
+ . '
Im Programm kannst du dir beim Anmelden eine neue Bestätigungsmail schicken lassen.
');
+}
diff --git a/server/sva.tyrveil.com/konto/passwort.php b/server/sva.tyrveil.com/konto/passwort.php
new file mode 100644
index 0000000..dda8e0d
--- /dev/null
+++ b/server/sva.tyrveil.com/konto/passwort.php
@@ -0,0 +1,41 @@
+Zur Verwaltung '
+ : 'Melde dich jetzt im Squad Manager mit dem neuen Passwort an. '
+ . 'Auf anderen Geräten wurdest du abgemeldet.
';
+ Web::seite('Passwort gespeichert', '
Passwort gespeichert ' . $weiter . '');
+ } catch (SmFehler $f) {
+ $fehler = Web::hinweis(Web::e($f->getMessage()), 'fehler');
+ }
+ }
+}
+
+if (Sicherheit::tokenFinden($token, 'passwort') === null) {
+ Web::seite('Passwort', 'Link ungültig '
+ . Web::hinweis('Dieser Link ist ungültig oder abgelaufen.', 'fehler')
+ . '
Neuen Link anfordern
');
+}
+
+Web::seite('Neues Passwort', '
Neues Passwort ' . $fehler
+ . '');
diff --git a/server/sva.tyrveil.com/konto/vergessen.php b/server/sva.tyrveil.com/konto/vergessen.php
new file mode 100644
index 0000000..98962d5
--- /dev/null
+++ b/server/sva.tyrveil.com/konto/vergessen.php
@@ -0,0 +1,17 @@
+getMessage()), 'fehler');
+ }
+}
+Web::seite('Passwort vergessen', '
Passwort vergessen ' . $inhalt
+ . '');
diff --git a/server/sva.tyrveil.com/verwaltung/index.php b/server/sva.tyrveil.com/verwaltung/index.php
new file mode 100644
index 0000000..16d5052
--- /dev/null
+++ b/server/sva.tyrveil.com/verwaltung/index.php
@@ -0,0 +1,5 @@
+.zip Paket fuer den Auto-Updater
SquadManager-Setup-.exe
version.json Steuerdatei fuer den Server
- server/ genau das, was hochgeladen wird
+ server/ Inhalt fuer /sva.tyrveil.com (Webseite, Updates, Schnittstelle)
+ sva-privat/ Logik des Servers, neben /sva.tyrveil.com - ohne config.php
Aufruf: .venv\\Scripts\\python.exe werkzeuge\\baue_release.py
"""
@@ -235,6 +236,23 @@ def seite_bauen(server, version, setup_pfad):
shutil.copy2(WURZEL / "icon.png", server / "icon.png")
+def server_dateien_bauen(server):
+ """
+ Oeffentliche PHP-Dateien nach server/, die Logik nach sva-privat/.
+
+ config.php und der Datenordner kommen nie mit: Die config.php auf dem
+ Server enthaelt das Datenbank-Passwort und darf beim Hochladen nicht
+ ueberschrieben werden.
+ """
+ quelle = WURZEL / "server"
+ shutil.copytree(quelle / "sva.tyrveil.com", server, dirs_exist_ok=True)
+ privat = DIST / "sva-privat"
+ if privat.exists():
+ shutil.rmtree(privat)
+ shutil.copytree(quelle / "sva-privat", privat,
+ ignore=shutil.ignore_patterns("config.php", "daten", "*.sqlite"))
+
+
def server_bauen(version, build, zip_pfad, setup_pfad):
server = DIST / "server"
if server.exists():
@@ -249,6 +267,7 @@ def server_bauen(version, build, zip_pfad, setup_pfad):
text = anleitung.read_text(encoding="utf-8").replace("__VERSION__", version)
(server / anleitung.name).write_text(text, encoding="utf-8", newline="\r\n")
seite_bauen(server, version, setup_pfad)
+ server_dateien_bauen(server)
pruefsumme = hashlib.sha256(zip_pfad.read_bytes()).hexdigest()
angaben = {
diff --git a/werkzeuge/server_test.py b/werkzeuge/server_test.py
new file mode 100644
index 0000000..2a9747a
--- /dev/null
+++ b/werkzeuge/server_test.py
@@ -0,0 +1,433 @@
+"""
+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""" ['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"").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("")
+ 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()