Server fuer Konten, Akten und Squads

PHP 8 ohne Framework unter server/: oeffentliche Einstiege fuer
sva.tyrveil.com (Schnittstelle, Konto-Links, Verwaltung, Einrichtung) und
die Logik in sva-privat neben dem Dokumentenstamm.

- Konten mit E-Mail-Bestaetigung, Anmeldung per Token, Passwort
  vergessen, Konto loeschen
- Akten auf dem Server mit serververgebener Aktennummer und
  Versionspruefung; Portraets werden neu als PNG gespeichert
- Squads mit Einladungen, Fuehrung uebergeben, Aufloesen
- Verwaltung fuer info@tyrveil.com: Nutzer, Charaktere, Squads
- Bremsen gegen Durchprobieren, Token nur als Hash, CSRF-Schutz

werkzeuge/server_test.py prueft alles lokal mit SQLite (91 Faelle).
Der Release-Bau legt dist/server und dist/sva-privat an, ohne config.php.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
danny 2026-09-13 17:50:33 +02:00
parent 58a3573fd6
commit 6e4d4afc1d
23 changed files with 2872 additions and 1 deletions

4
.gitignore vendored
View file

@ -9,3 +9,7 @@ __pycache__/
# Editor
.idea/
.vscode/
# Server: Zugangsdaten und Nutzerdaten nie ins Repository
server/sva-privat/config.php
server/sva-privat/daten/

View file

@ -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-<Jahr>-<id>`), 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

View file

@ -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:

View file

@ -0,0 +1,166 @@
<?php
/*
* Schnittstelle fuer das Programm.
*
* Alle Aufrufe: POST /api/ mit JSON {"aktion": "...", ...}. Angemeldete
* Aufrufe schicken das Sitzungstoken im Kopf X-SM-Token - nicht in
* Authorization, das Plesk-Konfigurationen gern verschlucken. Antwort immer
* JSON: {"ok": true, ...} oder {"ok": false, "fehler": "code", "meldung": "Text"}.
*/
declare(strict_types=1);
final class Api
{
private const OHNE_ANMELDUNG = ['status', 'registrieren', 'anmelden', 'bestaetigung_erneut', 'passwort_vergessen'];
private const MAX_ANFRAGE_BYTES = 12 * 1024 * 1024;
private static function senden(array $daten, int $http = 200): never
{
http_response_code($http);
header('Content-Type: application/json; charset=utf-8');
header('Cache-Control: no-store');
header('X-Content-Type-Options: nosniff');
echo json_encode($daten, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
exit;
}
private static function text(array $anfrage, string $feld, int $max = 1000): string
{
$wert = $anfrage[$feld] ?? '';
if (!is_string($wert) && !is_int($wert)) {
throw new SmFehler('feld_ungueltig', "Feld $feld ist ungültig.");
}
return mb_substr((string) $wert, 0, $max);
}
private static function zahl(array $anfrage, string $feld): int
{
$wert = $anfrage[$feld] ?? null;
if (!is_int($wert) && !(is_string($wert) && ctype_digit($wert))) {
throw new SmFehler('feld_ungueltig', "Feld $feld fehlt oder ist keine Zahl.");
}
return (int) $wert;
}
public static function behandeln(): never
{
try {
if (($_SERVER['REQUEST_METHOD'] ?? '') !== 'POST') {
throw new SmFehler('methode', 'Nur POST.', 405);
}
$roh = file_get_contents('php://input', false, null, 0, self::MAX_ANFRAGE_BYTES + 1);
if ($roh === false || strlen($roh) > 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);
}
}

View file

@ -0,0 +1,314 @@
<?php
/*
* Charaktere (Akten) auf dem Server.
*
* Die Akte selbst liegt als JSON in "daten", so wie das Programm sie
* speichert. Die Felder fuer Listen und Suche (Callsign, Rang, Status ...)
* werden beim Speichern daraus abgeleitet. Aktennummern vergibt der Server,
* damit sie ueber alle Spieler eindeutig sind.
*/
declare(strict_types=1);
final class Charaktere
{
public const MAX_JE_NUTZER = 50;
public const MAX_DATEN_BYTES = 262144;
public const MAX_BILD_BYTES = 8 * 1024 * 1024;
public const BILD_KANTE = 512;
private static function text(mixed $wert, int $max): string
{
return is_string($wert) ? mb_substr(trim($wert), 0, $max) : '';
}
/** Listenfelder aus der Akte. */
private static function felder(array $daten): array
{
$p = is_array($daten['personalien'] ?? null) ? $daten['personalien'] : [];
$d = is_array($daten['dienst'] ?? null) ? $daten['dienst'] : [];
return [
'callsign' => 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()];
}
}

View file

@ -0,0 +1,236 @@
<?php
/*
* Datenbankzugriff ueber PDO.
*
* Auf dem Server MySQL/MariaDB, bei den lokalen Tests SQLite. Die Abfragen
* sind so geschrieben, dass sie auf beiden laufen; die wenigen Unterschiede
* (Tabellenanlage, Zeilensperren) stecken hier.
*/
declare(strict_types=1);
final class DB
{
private static ?PDO $pdo = null;
public static function pdo(): PDO
{
if (self::$pdo === null) {
self::$pdo = new PDO(
(string) sm_config('datenbank.dsn'),
(string) sm_config('datenbank.benutzer', ''),
(string) sm_config('datenbank.passwort', ''),
[
PDO::ATTR_ERRMODE => 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);
}
}

View file

@ -0,0 +1,209 @@
<?php
/*
* Nutzerkonten: Registrierung mit E-Mail-Bestaetigung, Anmeldung,
* Passwort vergessen, Konto loeschen.
*/
declare(strict_types=1);
final class Konten
{
public static function oeffentlich(array $nutzer): array
{
return [
'id' => (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]);
});
}
}

View file

@ -0,0 +1,121 @@
<?php
/*
* E-Mail-Versand fuer Bestaetigung und Passwort.
*
* Standard ist PHPs mail(): Auf Plesk geht das an den lokalen Mailserver,
* der fuer die eigene Domain signiert und zustellt - ohne Postfach-Passwort
* in config.php. SMTP ist als Ausweg eingebaut, "datei" schreibt die Mails
* nur in einen Ordner (fuer Tests).
*/
declare(strict_types=1);
final class Mail
{
public static function senden(string $an, string $betreff, string $text): bool
{
$absender = (string) sm_config('mail.absender', 'info@tyrveil.com');
$name = (string) sm_config('mail.absender_name', 'Squad Manager');
$kopf = [
'From' => 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');
}
}

View file

@ -0,0 +1,144 @@
<?php
/*
* Token, Passwoerter und Bremsen gegen Durchprobieren und Spam.
*
* Token werden nur als SHA-256-Hash gespeichert: Wer die Datenbank liest,
* kann sich damit nicht anmelden. Passwoerter mit password_hash().
*/
declare(strict_types=1);
final class Sicherheit
{
public const SITZUNG_TAGE = 180;
public const PASSWORT_MIN = 10;
public static function zufall(int $bytes = 32): string
{
return bin2hex(random_bytes($bytes));
}
public static function hash(string $token): string
{
return hash('sha256', $token);
}
/** Legt ein Token an und gibt es im Klartext zurueck - nur dieses eine Mal. */
public static function tokenAnlegen(int $nutzerId, string $art, int $gueltigSekunden,
?string $geraet = null): string
{
$token = self::zufall();
DB::einfuegen('sm_token', [
'nutzer_id' => $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()]);
}
}

View file

@ -0,0 +1,317 @@
<?php
/*
* Squads: Ein Charakter gruendet ein Squad und fuehrt es. Er laedt andere
* Charaktere ein, deren Spieler annehmen muessen. Jeder Charakter ist in
* hoechstens einem Squad.
*
* Alle Aenderungen laufen in Transaktionen mit Zeilensperre, damit etwa zwei
* gleichzeitig angenommene Einladungen einen Charakter nicht doppelt
* zuordnen.
*/
declare(strict_types=1);
final class Squads
{
public const MAX_OFFENE_EINLADUNGEN = 30;
private static function eigenerCharakter(array $nutzer, int $charakterId): array
{
$zeile = DB::eine('SELECT * FROM sm_charakter WHERE id = ? AND nutzer_id = ?' . DB::sperre(),
[$charakterId, $nutzer['id']]);
if ($zeile === null) {
throw new SmFehler('charakter_nicht_gefunden',
'Diesen Charakter gibt es nicht oder er gehört dir nicht.', 404);
}
return $zeile;
}
private static function squadMitSperre(int $squadId): array
{
$squad = DB::eine('SELECT * FROM sm_squad WHERE id = ?' . DB::sperre(), [$squadId]);
if ($squad === null) {
throw new SmFehler('squad_nicht_gefunden', 'Dieses Squad gibt es nicht mehr.', 404);
}
return $squad;
}
private static function alsFuehrer(array $nutzer, int $squadId): array
{
$squad = self::squadMitSperre($squadId);
if (!DB::wert('SELECT 1 FROM sm_charakter WHERE id = ? AND nutzer_id = ?',
[$squad['fuehrer_id'], $nutzer['id']])) {
throw new SmFehler('kein_fuehrer', 'Das kann nur der Squadführer.', 403);
}
return $squad;
}
private static function name(string $name): string
{
$name = trim(preg_replace('/\s+/u', ' ', $name) ?? '');
if (mb_strlen($name) < 3 || mb_strlen($name) > 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);
}
}

View file

@ -0,0 +1,75 @@
<?php
/*
* Gemeinsamer Einstieg fuer alle Seiten und die Schnittstelle.
*
* Liegt ausserhalb des Web-Verzeichnisses. Die oeffentlichen Dateien unter
* /sva.tyrveil.com binden nur diese Datei ein; Logik, config.php und die
* Portraets sind so nicht ueber das Web abrufbar.
*/
declare(strict_types=1);
const SM_API_VERSION = 1;
const SM_STATUS = ['aktiv', 'verwundet', 'vermisst', 'gefallen', 'außer Dienst'];
define('SM_PRIVAT', dirname(__DIR__));
$smConfigPfad = SM_PRIVAT . '/config.php';
if (!is_file($smConfigPfad)) {
http_response_code(503);
header('Content-Type: text/plain; charset=utf-8');
exit("Squad Manager ist noch nicht eingerichtet: config.php fehlt im Ordner sva-privat.\n");
}
$GLOBALS['SM_CONFIG'] = require $smConfigPfad;
unset($smConfigPfad);
/** Liest einen Wert aus config.php, Pfad mit Punkten: 'mail.absender'. */
function sm_config(string $pfad, mixed $standard = null): mixed
{
$wert = $GLOBALS['SM_CONFIG'];
foreach (explode('.', $pfad) as $teil) {
if (!is_array($wert) || !array_key_exists($teil, $wert)) {
return $standard;
}
$wert = $wert[$teil];
}
return $wert;
}
function sm_daten_ordner(string $unter = ''): string
{
$ordner = rtrim((string) sm_config('daten_ordner', SM_PRIVAT . '/daten'), '/\\');
$pfad = $unter === '' ? $ordner : $ordner . '/' . $unter;
if (!is_dir($pfad)) {
@mkdir($pfad, 0770, true);
}
return $pfad;
}
function sm_log(string $text): void
{
@file_put_contents(sm_daten_ordner() . '/fehler.log',
'[' . gmdate('Y-m-d H:i:s') . "] $text\n", FILE_APPEND | LOCK_EX);
}
date_default_timezone_set('UTC');
ini_set('display_errors', sm_config('fehler_anzeigen', false) ? '1' : '0');
error_reporting(E_ALL);
mb_internal_encoding('UTF-8');
/** Fehler, die als verstaendliche Meldung beim Nutzer ankommen sollen. */
final class SmFehler extends RuntimeException
{
public function __construct(
public readonly string $fehlercode,
string $meldung,
public readonly int $http = 400,
public readonly array $extra = [],
) {
parent::__construct($meldung);
}
}
foreach (['db', 'sicherheit', 'mail', 'konten', 'charaktere', 'squads', 'web'] as $smDatei) {
require __DIR__ . "/$smDatei.php";
}
unset($smDatei);

View file

@ -0,0 +1,393 @@
<?php
/*
* Verwaltung unter /verwaltung/ - nur fuer Konten mit der Rolle admin.
*
* Eigene PHP-Sitzung (Cookie nur fuer /verwaltung/, HttpOnly, SameSite
* Strict), CSRF-Token fuer jede Aenderung, zwei Stunden Leerlauf.
* Loeschen fuehrt immer ueber eine Bestaetigungsseite; JavaScript gibt es
* bewusst keines.
*/
declare(strict_types=1);
final class Verwaltung
{
private const LEERLAUF = 7200;
public static function starten(): void
{
session_name('sm_verwaltung');
session_set_cookie_params([
'lifetime' => 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 '<input type="hidden" name="csrf" value="' . Web::e(self::csrf()) . '">';
}
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')
. '<p><a href="./">Zur Übersicht</a></p>');
}
}
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', '<div class="karte"><h1>Anmelden</h1>' . $fehler
. '<form method="post" action="./">' . self::csrfFeld()
. '<input type="hidden" name="aktion" value="anmelden">'
. '<label for="email">E-Mail</label><input type="email" id="email" name="email" autocomplete="username" required>'
. '<label for="passwort">Passwort</label><input type="password" id="passwort" name="passwort" autocomplete="current-password" required>'
. '<button type="submit">Anmelden</button></form>'
. '<p class="dim">Passwort vergessen? <a href="/konto/vergessen.php">Neues Passwort anfordern</a></p></div>');
}
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 = '<nav>';
foreach ($punkte as $seite => $text) {
$html .= '<a href="./?seite=' . $seite . '"' . ($seite === $aktiv ? ' class="aktiv"' : '') . ">$text</a>";
}
return $html . '<form method="post" action="./" style="margin-left:auto">' . self::csrfFeld()
. '<input type="hidden" name="aktion" value="abmelden"><button class="leise">Abmelden</button></form></nav>';
}
private static function knopf(string $aktion, int $id, string $text, bool $gefahr = false): string
{
return '<form method="post" action="./">' . self::csrfFeld()
. '<input type="hidden" name="aktion" value="' . Web::e($aktion) . '">'
. '<input type="hidden" name="id" value="' . $id . '">'
. '<button class="leise' . ($gefahr ? ' gefahr' : '') . '">' . Web::e($text) . '</button></form> ';
}
/** Loeschen und Aufloesen ueber eine eigene Seite statt ueber JavaScript-Rueckfragen. */
private static function loeschLink(string $aktion, int $id, string $text): string
{
return '<a class="dim" href="./?seite=bestaetigen&amp;aktion=' . Web::e($aktion) . '&amp;id=' . $id . '">'
. Web::e($text) . '</a>';
}
private static function datum(?string $wert): string
{
return $wert === null ? '<span class="dim">—</span>' : Web::e(substr($wert, 0, 16)) . ' <span class="dim">UTC</span>';
}
private static function suchfeld(string $seite): array
{
$suche = trim(mb_substr((string) ($_GET['q'] ?? ''), 0, 64));
$html = '<form class="suche" method="get" action="./"><input type="hidden" name="seite" value="' . $seite . '">'
. '<input type="search" name="q" value="' . Web::e($suche) . '" placeholder="Suchen …"><button>Suchen</button></form>';
$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() . '<h1>Übersicht</h1><div class="zahlen">';
foreach ($zahlen as $text => $wert) {
$html .= '<div><b>' . (int) $wert . '</b>' . Web::e($text) . '</div>';
}
$html .= '</div><h2>NEUESTE KONTEN</h2><div class="tabelle"><table><tr><th>Benutzername</th><th>E-Mail</th><th>Registriert</th></tr>';
foreach (DB::alle('SELECT benutzername, email, erstellt_am FROM sm_nutzer ORDER BY id DESC LIMIT 10') as $n) {
$html .= '<tr><td>' . Web::e($n['benutzername']) . '</td><td>' . Web::e($n['email']) . '</td><td>'
. self::datum($n['erstellt_am']) . '</td></tr>';
}
Web::seite('Verwaltung', $html . '</table></div>', '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() . '<h1>Nutzer</h1>' . $suchHtml
. '<div class="tabelle"><table><tr><th>Benutzername</th><th>E-Mail</th><th>Rolle</th><th>Bestätigt</th>'
. '<th>Charaktere</th><th>Registriert</th><th>Letzte Anmeldung</th><th></th></tr>';
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 .= '<tr><td>' . Web::e($n['benutzername']) . ($gesperrt ? ' <span class="hinweis fehler" style="padding:1px 6px">gesperrt</span>' : '')
. '</td><td>' . Web::e($n['email']) . '</td><td>' . Web::e($n['rolle']) . '</td><td>'
. ($n['email_bestaetigt_am'] === null ? '<span style="color:var(--amber)">nein</span>' : 'ja')
. '</td><td class="mono">' . (int) $n['anzahl'] . '</td><td>' . self::datum($n['erstellt_am'])
. '</td><td>' . self::datum($n['letzte_anmeldung_am']) . '</td><td>' . $aktionen . '</td></tr>';
}
Web::seite('Verwaltung', $html . '</table></div>', '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() . '<h1>Charaktere</h1>' . $suchHtml
. '<div class="tabelle"><table><tr><th>Akte</th><th>Callsign</th><th>Name</th><th>Dienstgrad</th>'
. '<th>Fraktion</th><th>Status</th><th>Spieler</th><th>Squad</th><th>Geändert</th><th></th></tr>';
foreach ($zeilen as $c) {
$id = (int) $c['id'];
$html .= '<tr><td class="mono">' . Web::e($c['aktennummer']) . '</td><td>' . Web::e($c['callsign'])
. '</td><td>' . Web::e(trim($c['vorname'] . ' ' . $c['nachname'])) . '</td><td>' . Web::e($c['rang'])
. '</td><td>' . Web::e(trim($c['fraktion'] . ($c['teilstreitkraft'] ? ' · ' . $c['teilstreitkraft'] : '')))
. '</td><td>' . Web::e($c['status']) . '</td><td>' . Web::e($c['spieler']) . '</td><td>'
. Web::e($c['squad'] ?? '—') . '</td><td>' . self::datum($c['geaendert_am']) . '</td><td>'
. '<a href="./?seite=charakter&amp;id=' . $id . '">Ansehen</a> · '
. self::loeschLink('charakter_loeschen', $id, 'Löschen …') . '</td></tr>';
}
Web::seite('Verwaltung', $html . '</table></div>', '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
? '<img src="./?seite=bild&amp;id=' . $id . '" alt="Porträt" style="max-width:220px;border:1px solid var(--line);float:right;margin:0 0 12px 18px">'
: '';
$html = '<h1>' . Web::e($c['callsign'] ?: trim($c['vorname'] . ' ' . $c['nachname'])) . '</h1><div class="karte">'
. $bild . '<p class="mono">' . Web::e($c['aktennummer']) . '</p><p>' . Web::e(trim($c['rang'] . ' '
. $c['vorname'] . ' ' . $c['nachname'])) . '<br>' . Web::e($c['fraktion']) . ' · ' . Web::e($c['teilstreitkraft'])
. '<br>Status: ' . Web::e($c['status']) . '</p><p class="dim">Spieler: ' . Web::e($c['spieler']) . ' (' . Web::e($c['email'])
. ')<br>Version ' . (int) $c['version'] . ', geändert ' . self::datum($c['geaendert_am']) . '</p>'
. '<p>' . self::loeschLink('charakter_loeschen', $id, 'Charakter löschen …') . '</p>'
. '<h2>AKTE (ROHDATEN)</h2><pre>' . Web::e($daten) . '</pre></div>';
Web::seite('Verwaltung', $html, '900px', self::navigation('charaktere'));
}
private static function seiteSquads(): never
{
$html = self::meldung() . '<h1>Squads</h1><div class="tabelle"><table><tr><th>Name</th><th>Führer</th>'
. '<th>Mitglieder</th><th>Gegründet</th><th></th></tr>';
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 .= '<tr><td>' . Web::e($s['name']) . '</td><td>' . Web::e($fuehrer[0]['callsign'] ?? '—') . '</td><td>'
. implode(', ', $namen) . '</td><td>' . self::datum($s['erstellt_am']) . '</td><td>'
. self::loeschLink('squad_aufloesen', (int) $s['id'], 'Auflösen …') . '</td></tr>';
}
Web::seite('Verwaltung', $html . '</table></div>', '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 = '<div class="karte"><h1>Bestätigen</h1><p><b>' . Web::e($name() ?? '?') . '</b></p><p>' . Web::e($frage) . '</p>'
. '<form method="post" action="./">' . self::csrfFeld() . '<input type="hidden" name="aktion" value="' . Web::e($aktion) . '">'
. '<input type="hidden" name="id" value="' . $id . '"><button class="gefahr">Ja, ausführen</button> '
. '<a class="knopf" style="background:transparent;color:var(--fg);border-color:var(--line)" href="./?seite=' . $zurueck . '">Abbrechen</a></form></div>';
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;
}
}

View file

@ -0,0 +1,110 @@
<?php
/*
* Gemeinsames Aussehen der Webseiten (Konto-Links, Verwaltung, Einrichtung)
* im Stil der Downloadseite, dazu die Sicherheitskoepfe.
*/
declare(strict_types=1);
final class Web
{
public static function e(mixed $text): string
{
return htmlspecialchars((string) $text, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}
public static function sicherheitskoepfe(): void
{
header('Content-Type: text/html; charset=utf-8');
header('X-Content-Type-Options: nosniff');
header('X-Frame-Options: DENY');
// Links aus Mails tragen ein Token in der Adresse - nie an Dritte weiterreichen
header('Referrer-Policy: no-referrer');
header('Cache-Control: no-store');
header("Content-Security-Policy: default-src 'none'; style-src 'unsafe-inline'; img-src 'self';"
. " form-action 'self'; frame-ancestors 'none'; base-uri 'none'");
}
public static function hinweis(string $text, string $art = 'info'): string
{
return '<p class="hinweis ' . self::e($art) . '">' . $text . '</p>';
}
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 <<<HTML
<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="robots" content="noindex">
<title>$titelE – Squad Manager</title>
<link rel="icon" href="/icon.png">
<style>
:root { --bg:#151814; --panel:#1e231b; --panel-hi:#2a3125; --line:#3d4634; --fg:#c9cec0;
--dim:#7f8874; --olive:#6e8b3d; --olive-hi:#8cb04d; --amber:#d9a441; --rot:#b4472f;
--mono: Consolas, "Cascadia Mono", monospace; }
* { box-sizing: border-box; }
body { margin:0; background:var(--bg); color:var(--fg); font:15px/1.55 "Segoe UI", system-ui, sans-serif; }
main { max-width:$breite; margin:0 auto; padding:40px 20px; }
.kopf { display:flex; align-items:center; gap:14px; margin-bottom:28px; }
.kopf img { width:44px; height:44px; }
.kopf b { font-size:20px; letter-spacing:.04em; display:block; }
.kopf span { color:var(--dim); font-size:13px; }
h1 { font:700 14px var(--mono); letter-spacing:.08em; color:var(--olive-hi); text-transform:uppercase;
border-bottom:1px solid var(--line); padding-bottom:6px; margin:0 0 18px; }
h2 { font:700 13px var(--mono); letter-spacing:.06em; color:var(--olive-hi); margin:26px 0 10px; }
.karte { background:var(--panel); border:1px solid var(--line); padding:22px 24px; margin-bottom:18px; }
a { color:var(--olive-hi); }
label { display:block; margin:12px 0 4px; color:var(--dim); font-size:13px; }
input[type=text], input[type=email], input[type=password], input[type=search] {
width:100%; padding:9px 10px; background:var(--bg); color:var(--fg); border:1px solid var(--line);
font:inherit; }
input:focus { outline:1px solid var(--olive); }
button, .knopf { display:inline-block; margin-top:14px; padding:9px 18px; background:var(--olive);
color:#10130d; border:1px solid var(--olive-hi); font:600 14px "Segoe UI", sans-serif; cursor:pointer;
text-decoration:none; }
button.leise { background:transparent; color:var(--fg); border-color:var(--line); margin-top:0; padding:4px 10px; font-weight:400; }
button.gefahr { background:var(--rot); border-color:#d0664c; color:#fff; }
button.leise.gefahr { background:transparent; color:#e08a74; border-color:#6b3528; }
.hinweis { padding:10px 14px; border-left:3px solid var(--olive); background:var(--panel-hi); }
.hinweis.fehler { border-color:var(--rot); color:#f0b3a3; }
.hinweis.warnung { border-color:var(--amber); color:var(--amber); }
table { width:100%; border-collapse:collapse; font-size:14px; }
th { text-align:left; font:700 12px var(--mono); color:var(--dim); letter-spacing:.05em; padding:6px 8px;
border-bottom:1px solid var(--line); white-space:nowrap; }
td { padding:7px 8px; border-bottom:1px solid var(--panel-hi); vertical-align:top; }
td form { display:inline; }
.tabelle { overflow-x:auto; }
.dim { color:var(--dim); }
.mono { font-family:var(--mono); }
nav { display:flex; flex-wrap:wrap; gap:4px 18px; margin:-10px 0 24px; font:13px var(--mono); }
nav a { text-decoration:none; color:var(--fg); }
nav a.aktiv { color:var(--olive-hi); }
.zahlen { display:grid; grid-template-columns:repeat(auto-fill, minmax(150px, 1fr)); gap:12px; }
.zahlen div { background:var(--panel); border:1px solid var(--line); padding:12px 14px; }
.zahlen b { display:block; font:700 26px var(--mono); color:var(--olive-hi); }
pre { white-space:pre-wrap; word-break:break-word; background:var(--bg); border:1px solid var(--line);
padding:12px; font:12px var(--mono); max-height:420px; overflow:auto; }
.suche { display:flex; gap:8px; margin-bottom:14px; }
.suche button { margin-top:0; }
footer { max-width:$breite; margin:0 auto; padding:0 20px 40px; font:12px var(--mono); color:var(--dim); }
footer a { color:var(--dim); }
</style>
</head>
<body>
<main>
<div class="kopf"><img src="/icon.png" alt=""><div><b>SQUAD MANAGER</b><span>$titelE</span></div></div>
$navigation
$inhalt
</main>
<footer><a href="$rechtliches">Impressum und Datenschutz</a></footer>
</body>
</html>
HTML;
exit;
}
}

View file

@ -0,0 +1,46 @@
<?php
/*
* Vorlage fuer die Einstellungen des Servers.
*
* Als config.php in denselben Ordner kopieren (sva-privat/config.php) und
* ausfuellen. config.php enthaelt das Datenbank-Passwort: Sie gehoert
* nicht ins Repository und nicht in den Web-Ordner.
*/
return [
'datenbank' => [
// 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,
];

View file

@ -0,0 +1,24 @@
<?php
// Portraet eines Charakters, nur fuer angemeldete Programme (Kopf X-SM-Token).
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
header('X-Content-Type-Options: nosniff');
if (Sicherheit::sitzung((string) ($_SERVER['HTTP_X_SM_TOKEN'] ?? '')) === null) {
http_response_code(401);
exit;
}
$pfad = Charaktere::bildPfad((int) ($_GET['id'] ?? 0));
if ($pfad === null) {
http_response_code(404);
exit;
}
$etag = '"' . basename($pfad, '.png') . '"';
header('ETag: ' . $etag);
header('Cache-Control: private, max-age=300');
if (($_SERVER['HTTP_IF_NONE_MATCH'] ?? '') === $etag) {
http_response_code(304);
exit;
}
header('Content-Type: image/png');
header('Content-Length: ' . filesize($pfad));
readfile($pfad);

View file

@ -0,0 +1,5 @@
<?php
// Schnittstelle fuer das Programm. Die Logik liegt ausserhalb des Web-Ordners.
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
require SM_PRIVAT . '/app/api.php';
Api::behandeln();

View file

@ -0,0 +1,90 @@
<?php
/*
* Ersteinrichtung: legt die Tabellen an und den Verwaltungszugang fuer
* admin_email. Nur mit dem einrichtungs_schluessel aus config.php nutzbar;
* ist der Schluessel leer, ist diese Seite abgeschaltet. Mehrfach aufrufen
* schadet nicht - vorhandene Tabellen und Daten bleiben unberuehrt.
*/
require dirname(__DIR__) . '/sva-privat/app/start.php';
$schluessel = (string) sm_config('einrichtungs_schluessel', '');
if (strlen($schluessel) < 24) {
Web::seite('Einrichtung', '<div class="karte"><h1>Einrichtung abgeschaltet</h1>'
. '<p>Zum Einrichten in <span class="mono">sva-privat/config.php</span> einen '
. '<span class="mono">einrichtungs_schluessel</span> mit mindestens 24 Zeichen eintragen.</p></div>');
}
$form = '<form method="post" action="einrichten.php"><label for="schluessel">Einrichtungsschlüssel aus config.php</label>'
. '<input type="password" id="schluessel" name="schluessel" required><button type="submit">Einrichten</button></form>';
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
Web::seite('Einrichtung', '<div class="karte"><h1>Einrichtung</h1>' . $form . '</div>');
}
if (!hash_equals($schluessel, (string) ($_POST['schluessel'] ?? ''))) {
sleep(2);
Web::seite('Einrichtung', '<div class="karte"><h1>Einrichtung</h1>'
. Web::hinweis('Der Schlüssel stimmt nicht.', 'fehler') . $form . '</div>');
}
$zeilen = [];
$ok = true;
$pruefen = function (string $text, bool $bestanden, string $hilfe = '') use (&$zeilen, &$ok) {
$ok = $ok && $bestanden;
$zeilen[] = '<tr><td>' . ($bestanden ? '✓' : '<b style="color:#e08a74">✗</b>') . '</td><td>' . Web::e($text)
. ($bestanden || $hilfe === '' ? '' : '<br><span class="dim">' . Web::e($hilfe) . '</span>') . '</td></tr>';
};
$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 <b>' . Web::e($email)
. '</b>. Es gilt nur der zuletzt verschickte Link. Falls die Mail nicht ankommt, kannst du ihn auch direkt hier öffnen:<br>'
. '<a class="mono" href="' . Web::e($link) . '">Passwort jetzt festlegen</a>', 'warnung');
} else {
$adminHinweis = Web::hinweis('Der Verwaltungszugang hat schon ein Passwort. Vergessen? '
. '<a href="/konto/vergessen.php">Neues anfordern</a>');
}
} 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', '<div class="karte"><h1>Einrichtung</h1><table>' . implode('', $zeilen) . '</table></div>'
. $adminHinweis
. ($ok ? Web::hinweis('Fertig. Trage in <span class="mono">config.php</span> den '
. '<span class="mono">einrichtungs_schluessel</span> 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')));

View file

@ -0,0 +1,14 @@
<?php
// Link aus der Bestaetigungsmail.
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
try {
$nutzer = Konten::bestaetigen((string) ($_GET['t'] ?? ''));
Web::seite('E-Mail bestätigt', '<div class="karte"><h1>E-Mail bestätigt</h1>'
. '<p>Danke, ' . Web::e($nutzer['benutzername']) . '. Deine Adresse ist bestätigt.</p>'
. '<p>Du kannst dich jetzt im Squad Manager anmelden.</p></div>');
} catch (SmFehler $fehler) {
Web::seite('E-Mail bestätigen', '<div class="karte"><h1>Link ungültig</h1>'
. Web::hinweis(Web::e($fehler->getMessage()), 'fehler')
. '<p>Im Programm kannst du dir beim Anmelden eine neue Bestätigungsmail schicken lassen.</p></div>');
}

View file

@ -0,0 +1,41 @@
<?php
// Neues Passwort festlegen - Link aus der Mail "Passwort vergessen" oder der Einrichtung.
// Das Formular kommt erst per GET, gesetzt wird per POST: Mailprogramme, die Links
// vorab aufrufen, verbrauchen den Link so nicht.
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
$token = (string) ($_POST['t'] ?? $_GET['t'] ?? '');
$fehler = '';
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
$passwort = (string) ($_POST['passwort'] ?? '');
if (!hash_equals($passwort, (string) ($_POST['wiederholung'] ?? ''))) {
$fehler = Web::hinweis('Die beiden Passwörter stimmen nicht überein.', 'fehler');
} else {
try {
$nutzer = Konten::passwortSetzen($token, $passwort);
$weiter = $nutzer['rolle'] === 'admin'
? '<p><a class="knopf" href="/verwaltung/">Zur Verwaltung</a></p>'
: '<p>Melde dich jetzt im Squad Manager mit dem neuen Passwort an. '
. 'Auf anderen Geräten wurdest du abgemeldet.</p>';
Web::seite('Passwort gespeichert', '<div class="karte"><h1>Passwort gespeichert</h1>' . $weiter . '</div>');
} catch (SmFehler $f) {
$fehler = Web::hinweis(Web::e($f->getMessage()), 'fehler');
}
}
}
if (Sicherheit::tokenFinden($token, 'passwort') === null) {
Web::seite('Passwort', '<div class="karte"><h1>Link ungültig</h1>'
. Web::hinweis('Dieser Link ist ungültig oder abgelaufen.', 'fehler')
. '<p><a href="/konto/vergessen.php">Neuen Link anfordern</a></p></div>');
}
Web::seite('Neues Passwort', '<div class="karte"><h1>Neues Passwort</h1>' . $fehler
. '<form method="post" action="passwort.php">'
. '<input type="hidden" name="t" value="' . Web::e($token) . '">'
. '<label for="passwort">Neues Passwort (mindestens ' . Sicherheit::PASSWORT_MIN . ' Zeichen)</label>'
. '<input type="password" id="passwort" name="passwort" autocomplete="new-password" required minlength="' . Sicherheit::PASSWORT_MIN . '">'
. '<label for="wiederholung">Wiederholen</label>'
. '<input type="password" id="wiederholung" name="wiederholung" autocomplete="new-password" required>'
. '<button type="submit">Passwort speichern</button></form></div>');

View file

@ -0,0 +1,17 @@
<?php
// Passwort vergessen - auch fuer die Verwaltung erreichbar.
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
$inhalt = '';
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
try {
Konten::passwortVergessen((string) ($_POST['email'] ?? ''));
$inhalt = Web::hinweis('Falls ein Konto zu dieser Adresse gehört, ist eine Mail mit einem Link unterwegs.');
} catch (SmFehler $f) {
$inhalt = Web::hinweis(Web::e($f->getMessage()), 'fehler');
}
}
Web::seite('Passwort vergessen', '<div class="karte"><h1>Passwort vergessen</h1>' . $inhalt
. '<form method="post" action="vergessen.php"><label for="email">E-Mail-Adresse deines Kontos</label>'
. '<input type="email" id="email" name="email" autocomplete="email" required>'
. '<button type="submit">Link schicken</button></form></div>');

View file

@ -0,0 +1,5 @@
<?php
// Verwaltung fuer den Admin-Zugang.
require dirname(__DIR__, 2) . '/sva-privat/app/start.php';
require SM_PRIVAT . '/app/verwaltung.php';
Verwaltung::behandeln();

View file

@ -6,7 +6,8 @@ Ergebnis in dist/:
SquadManager-<v>.zip Paket fuer den Auto-Updater
SquadManager-Setup-<v>.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 = {

433
werkzeuge/server_test.py Normal file
View file

@ -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"""<?php
return [
'datenbank' => ['dsn' => '{dsn}', 'benutzer' => '', 'passwort' => ''],
'basis_url' => '{self.basis}',
'rechtliches_url' => 'https://tyrveil.com/rechtliches#impressum',
'admin_email' => 'info@tyrveil.com',
'mail' => ['art' => 'datei', 'absender' => 'info@tyrveil.com', 'absender_name' => 'Squad Manager'],
'einrichtungs_schluessel' => '{SCHLUESSEL}',
'daten_ordner' => __DIR__ . '/daten',
'fehler_anzeigen' => false,
];
""", encoding="utf-8")
self.prozess = subprocess.Popen(
["php", "-S", f"127.0.0.1:{self.port}", "-t", str(self.ordner / "sva.tyrveil.com")],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
for _ in range(50):
try:
socket.create_connection(("127.0.0.1", self.port), timeout=0.2).close()
break
except OSError:
time.sleep(0.1)
def beenden(self):
self.prozess.terminate()
self.prozess.wait(timeout=10)
shutil.rmtree(self.ordner, ignore_errors=True)
@property
def daten(self):
return self.ordner / "sva-privat" / "daten"
def letzte_mail(self, an):
mails = sorted((self.daten / "mails").glob("*.eml"), key=lambda p: p.stat().st_mtime_ns)
for pfad in reversed(mails):
roh = pfad.read_bytes()
kopf, _, inhalt = roh.partition(b"\r\n\r\n")
if f"To: {an}".encode() in kopf:
return quopri.decodestring(inhalt).decode("utf-8")
return ""
def link_aus_mail(self, an):
treffer = re.search(r"http://127\.0\.0\.1:\d+/\S+", self.letzte_mail(an))
return treffer.group(0) if treffer else ""
# -- HTTP ---------------------------------------------------------------
def api(self, aktion, token=None, **felder):
anfrage = urllib.request.Request(
self.basis + "/api/", data=json.dumps({"aktion": aktion, **felder}).encode(),
headers={"Content-Type": "application/json", **({"X-SM-Token": token} if token else {})},
method="POST")
try:
with urllib.request.urlopen(anfrage, timeout=30) as antwort:
return antwort.status, json.loads(antwort.read())
except urllib.error.HTTPError as fehler:
text = fehler.read()
try:
return fehler.code, json.loads(text)
except ValueError:
return fehler.code, {"roh": text[:300]}
def roh(self, pfad, daten=None, token=None, oeffner=None, methode=None):
kodiert = urllib.parse.urlencode(daten).encode() if daten is not None else None
anfrage = urllib.request.Request(self.basis + pfad, data=kodiert, method=methode,
headers={"X-SM-Token": token} if token else {})
try:
with (oeffner or urllib.request.build_opener()).open(anfrage, timeout=30) as antwort:
return antwort.status, antwort.read(), dict(antwort.headers)
except urllib.error.HTTPError as fehler:
return fehler.code, fehler.read(), dict(fehler.headers)
def akte(lokale_id, callsign, nachname, rang="", status="aktiv"):
return {"schema": 1, "id": lokale_id, "aktennummer": "SM-2026-0001",
"personalien": {"vorname": "Test", "nachname": nachname, "callsign": callsign},
"dienst": {"fraktion": "Bundeswehr", "teilstreitkraft": "Heer", "rang": rang,
"verwendung": "Medic", "status": status},
"beschreibung": "", "auszeichnungen": [], "einsaetze": [], "vermerke": ""}
def png_base64(breite=900, hoehe=1200):
puffer = io.BytesIO()
Image.new("RGB", (breite, hoehe), (80, 90, 60)).save(puffer, "JPEG")
return base64.b64encode(puffer.getvalue()).decode()
def main():
s = Server()
try:
ablauf(s)
finally:
log = s.daten / "fehler.log"
inhalt = log.read_text(encoding="utf-8") if log.exists() else ""
pruefe("fehler.log des Servers leer", not inhalt.strip(), inhalt[-600:])
s.beenden()
print(f"\nERGEBNIS: {ergebnisse['ok']} bestanden, {ergebnisse['fehl']} fehlgeschlagen")
sys.exit(1 if ergebnisse["fehl"] else 0)
def ablauf(s):
print("Einrichtung")
code, html, kopf = s.roh("/einrichten.php")
pruefe("Formular erreichbar", code == 200 and b"Einrichtungsschl" in html, code)
pruefe("Sicherheitskopf Referrer-Policy", kopf.get("Referrer-Policy") == "no-referrer", kopf)
code, html, _ = s.roh("/einrichten.php", {"schluessel": "falsch"})
pruefe("falscher Schlüssel abgewiesen", "stimmt nicht" in html.decode())
code, html, _ = s.roh("/einrichten.php", {"schluessel": SCHLUESSEL})
text = html.decode()
pruefe("Tabellen angelegt", "7 Tabellen vorhanden" in text, text[-500:])
admin_link = s.link_aus_mail("info@tyrveil.com")
pruefe("Passwort-Mail an info@tyrveil.com", "/konto/passwort.php?t=" in admin_link, admin_link)
code, html, _ = s.roh("/einrichten.php", {"schluessel": SCHLUESSEL})
pruefe("zweiter Aufruf schadet nicht", "vorhanden" in html.decode())
erster_link, admin_link = admin_link, s.link_aus_mail("info@tyrveil.com")
pruefe("zweiter Aufruf schickt neuen Link", admin_link and admin_link != erster_link)
code, html, _ = s.roh(urllib.parse.urlparse(erster_link).path + "?" + urllib.parse.urlparse(erster_link).query)
pruefe("erster Link damit ungültig", "ungültig" in html.decode())
print("Schnittstelle allgemein")
code, antwort = s.api("status")
pruefe("status", code == 200 and antwort.get("api") == 1, antwort)
code, _, _ = s.roh("/api/", methode="GET")
pruefe("GET wird abgewiesen (405)", code == 405, code)
code, antwort = s.api("charaktere_alle")
pruefe("ohne Token: nicht_angemeldet (401)", code == 401 and antwort["fehler"] == "nicht_angemeldet", antwort)
code, antwort = s.api("gibtsnicht", token="0" * 64)
pruefe("falsches Token: 401", code == 401, antwort)
print("Registrierung")
for name, email, pw, erwartet in (
("al", "al@example.org", "langespasswort1", "benutzername_ungueltig"),
("alice", "keine-mail", "langespasswort1", "email_ungueltig"),
("alice", "alice@example.org", "kurz", "passwort_zu_schwach")):
code, antwort = s.api("registrieren", benutzername=name, email=email, passwort=pw)
pruefe(f"abgewiesen: {erwartet}", antwort.get("fehler") == erwartet, antwort)
code, antwort = s.api("registrieren", benutzername="Alice", email="Alice@Example.org", passwort="alicepasswort1")
pruefe("Alice registriert", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("registrieren", benutzername="bob", email="bob@example.org", passwort="bobpasswort12")
pruefe("Bob registriert", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("registrieren", benutzername="ALICE", email="neu@example.org", passwort="alicepasswort1")
pruefe("Benutzername doppelt (Groß/klein egal)", antwort.get("fehler") == "benutzername_vergeben", antwort)
code, antwort = s.api("anmelden", login="alice", passwort="alicepasswort1")
pruefe("vor Bestätigung: nicht_bestaetigt", antwort.get("fehler") == "nicht_bestaetigt", antwort)
for wer in ("alice@example.org", "bob@example.org"):
link = s.link_aus_mail(wer)
code, html, _ = s.roh(urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query)
pruefe(f"Bestätigungslink {wer.split('@')[0]}", code == 200 and "bestätigt" in html.decode(), link)
code, html, _ = s.roh(urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query)
pruefe("Link nur einmal gültig", "ungültig" in html.decode())
print("Anmeldung")
code, antwort = s.api("anmelden", login="alice", passwort="falsch-falsch")
pruefe("falsches Passwort", antwort.get("fehler") == "anmeldung_falsch", antwort)
code, antwort = s.api("anmelden", login="ALICE@example.org", passwort="alicepasswort1", geraet="Test-PC")
alice = antwort.get("token")
pruefe("Alice per E-Mail angemeldet", code == 200 and alice and antwort["nutzer"]["benutzername"] == "Alice", antwort)
code, antwort = s.api("anmelden", login="bob", passwort="bobpasswort12")
bob = antwort.get("token")
pruefe("Bob angemeldet", bool(bob), antwort)
code, antwort = s.api("ich", token=alice)
pruefe("ich", antwort.get("nutzer", {}).get("email") == "alice@example.org", antwort)
print("Charaktere")
ids = {n: f"{i:032x}" for i, n in enumerate(("nordlicht", "rook", "frost"), start=11)}
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"],
daten=akte(ids["nordlicht"], "Nordlicht", "Brandt", "Oberfeldwebel"))
nordlicht = antwort.get("charakter", {})
pruefe("Akte gespeichert, Server vergibt Nummer",
code == 200 and re.fullmatch(r"SM-\d{4}-\d{4}", nordlicht.get("aktennummer") or "")
and nordlicht["daten"]["aktennummer"] == nordlicht["aktennummer"], antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["frost"],
daten=akte(ids["frost"], "Frost", "Sigurdsson"))
frost = antwort.get("charakter", {})
code, antwort = s.api("charakter_speichern", token=bob, lokale_id=ids["rook"],
daten=akte(ids["rook"], "Rook", "Hutchins", status="gefallen"))
rook = antwort.get("charakter", {})
nummern = {nordlicht.get("aktennummer"), frost.get("aktennummer"), rook.get("aktennummer")}
pruefe("Aktennummern eindeutig", len(nummern) == 3 and None not in nummern, nummern)
geaendert = akte(ids["nordlicht"], "Nordlicht", "Brandt", "Hauptfeldwebel")
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert,
basis_version=1)
pruefe("Änderung mit passender Version", antwort.get("charakter", {}).get("version") == 2, antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert,
basis_version=1)
pruefe("veraltete Version: konflikt (409) mit Serverstand",
code == 409 and antwort.get("charakter", {}).get("version") == 2, antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert,
basis_version=1, erzwingen=True)
pruefe("erzwingen überschreibt", antwort.get("charakter", {}).get("version") == 3, antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id="kaputt", daten={})
pruefe("ungültige Akten-ID", antwort.get("fehler") == "lokale_id_ungueltig", antwort)
code, antwort = s.api("portraet_hochladen", token=alice, lokale_id=ids["nordlicht"], bild=png_base64())
pruefe("Porträt hochgeladen", antwort.get("charakter", {}).get("portraet") is True, antwort)
code, bild, kopf = s.roh(f"/api/bild.php?id={nordlicht['id']}", token=bob)
groesse = Image.open(io.BytesIO(bild)).size if code == 200 else None
pruefe("Porträt für andere abrufbar, neu als PNG ≤ 512",
code == 200 and kopf.get("Content-Type") == "image/png" and max(groesse) == 512, (code, groesse))
code, _, _ = s.roh(f"/api/bild.php?id={nordlicht['id']}")
pruefe("Porträt ohne Token: 401", code == 401, code)
code, antwort = s.api("portraet_hochladen", token=alice, lokale_id=ids["nordlicht"],
bild=base64.b64encode(b"<?php echo 1; ?>").decode())
pruefe("keine Bilddatei: abgewiesen", antwort.get("fehler") == "bild_ungueltig", antwort)
code, antwort = s.api("portraet_hochladen", token=bob, lokale_id=ids["nordlicht"], bild=png_base64(10, 10))
pruefe("fremde Akte: nicht gefunden", antwort.get("fehler") == "charakter_nicht_gefunden", antwort)
code, antwort = s.api("charaktere_alle", token=bob)
liste = antwort.get("charaktere", [])
pruefe("Bob sieht alle 3 Charaktere mit Status",
len(liste) == 3 and {c["callsign"]: c["status"] for c in liste}.get("Rook") == "gefallen", liste)
pruefe("'eigener' richtig gesetzt", [c["callsign"] for c in liste if c["eigener"]] == ["Rook"], liste)
code, antwort = s.api("charaktere_alle", token=bob, suche="nord")
pruefe("Suche", [c["callsign"] for c in antwort.get("charaktere", [])] == ["Nordlicht"], antwort)
code, antwort = s.api("charaktere_alle", token=bob, suche="100%_")
pruefe("Suche mit Sonderzeichen", code == 200 and antwort.get("charaktere") == [], antwort)
code, antwort = s.api("charakter_ansehen", token=bob, id=nordlicht["id"])
pruefe("fremde Akte ansehen", antwort.get("charakter", {}).get("daten", {}).get("dienst", {}).get("rang")
== "Hauptfeldwebel", antwort)
print("Squads")
code, antwort = s.api("squad_gruenden", token=alice, charakter_id=nordlicht["id"], name=" Nordwind ")
squad = antwort.get("squad", {})
pruefe("Squad gegründet", squad.get("name") == "Nordwind" and squad.get("fuehrer_id") == nordlicht["id"], antwort)
code, antwort = s.api("squad_gruenden", token=bob, charakter_id=rook["id"], name="nordwind")
pruefe("Name doppelt", antwort.get("fehler") == "name_vergeben", antwort)
code, antwort = s.api("squad_gruenden", token=bob, charakter_id=nordlicht["id"], name="Fremd")
pruefe("fremder Charakter kann nicht gründen", antwort.get("fehler") == "charakter_nicht_gefunden", antwort)
code, antwort = s.api("squad_einladen", token=bob, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("Nicht-Führer kann nicht einladen", antwort.get("fehler") == "kein_fuehrer", antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
einladung = antwort.get("einladung", {})
pruefe("Alice lädt Rook ein", einladung.get("status") == "offen", antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("doppelte Einladung", antwort.get("fehler") == "schon_eingeladen", antwort)
code, antwort = s.api("einladungen", token=bob)
pruefe("Bob sieht Einladung im Eingang", [e["squad"]["name"] for e in antwort.get("eingang", [])] == ["Nordwind"], antwort)
code, antwort = s.api("einladungen", token=alice)
pruefe("Alice sieht sie im Ausgang", len(antwort.get("ausgang", [])) == 1, antwort)
code, antwort = s.api("einladung_beantworten", token=alice, einladung_id=einladung["id"], annehmen=True)
pruefe("Alice kann Bobs Einladung nicht annehmen", antwort.get("fehler") == "charakter_nicht_gefunden", antwort)
code, antwort = s.api("einladung_beantworten", token=bob, einladung_id=einladung["id"], annehmen=True)
pruefe("Bob nimmt an", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("einladung_beantworten", token=bob, einladung_id=einladung["id"], annehmen=True)
pruefe("zweimal annehmen geht nicht", antwort.get("fehler") == "einladung_nicht_offen", antwort)
code, antwort = s.api("squad_gruenden", token=bob, charakter_id=rook["id"], name="Zweites")
pruefe("im Squad kein zweites gründen", antwort.get("fehler") == "bereits_im_squad", antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=frost["id"])
frost_einladung = antwort.get("einladung", {})
code, antwort = s.api("einladung_zurueckziehen", token=alice, einladung_id=frost_einladung.get("id"))
pruefe("Einladung zurückgezogen", code == 200, antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=frost["id"])
code, antwort = s.api("einladung_beantworten", token=alice, einladung_id=antwort["einladung"]["id"], annehmen=False)
pruefe("Einladung abgelehnt", code == 200, antwort)
code, antwort = s.api("squad_ansehen", token=bob, squad_id=squad["id"])
pruefe("Squad hat 2 Mitglieder", [m["callsign"] for m in antwort.get("squad", {}).get("mitglieder", [])]
== ["Nordlicht", "Rook"], antwort)
code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"])
pruefe("Führer mit Mitgliedern muss übergeben", antwort.get("fehler") == "fuehrer_muss_uebergeben", antwort)
code, antwort = s.api("squad_fuehrung_uebergeben", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("Führung an Rook übergeben", code == 200, antwort)
code, antwort = s.api("squad_entfernen", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("Ex-Führer kann nicht mehr entfernen", antwort.get("fehler") == "kein_fuehrer", antwort)
code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"])
pruefe("Nordlicht verlässt das Squad", code == 200, antwort)
code, antwort = s.api("squad_einladen", token=bob, squad_id=squad["id"], charakter_id=nordlicht["id"])
s.api("einladung_beantworten", token=alice, einladung_id=antwort["einladung"]["id"], annehmen=True)
code, antwort = s.api("charakter_loeschen", token=bob, lokale_id=ids["rook"])
pruefe("Führer gelöscht", code == 200, antwort)
code, antwort = s.api("squad_ansehen", token=alice, squad_id=squad["id"])
pruefe("dienstältestes Mitglied übernimmt", antwort.get("squad", {}).get("fuehrer_id") == nordlicht["id"], antwort)
code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"])
code, antwort = s.api("squads", token=alice)
pruefe("letztes Mitglied geht: Squad aufgelöst", antwort.get("squads") == [], antwort)
print("Passwort vergessen")
code, antwort = s.api("passwort_vergessen", email="gibtsnicht@example.org")
pruefe("unbekannte Adresse: gleiche Antwort", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("passwort_vergessen", email="alice@example.org")
link = s.link_aus_mail("alice@example.org")
pfad = urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query
code, html, _ = s.roh(pfad)
pruefe("Formular per GET, Link noch nicht verbraucht", code == 200 and "Neues Passwort" in html.decode(), link)
token = urllib.parse.parse_qs(urllib.parse.urlparse(link).query)["t"][0]
code, html, _ = s.roh("/konto/passwort.php", {"t": token, "passwort": "neuespasswort1", "wiederholung": "anders"})
pruefe("Wiederholung falsch", "stimmen nicht" in html.decode())
code, html, _ = s.roh("/konto/passwort.php", {"t": token, "passwort": "neuespasswort1", "wiederholung": "neuespasswort1"})
pruefe("neues Passwort gespeichert", "Passwort gespeichert" in html.decode())
code, antwort = s.api("ich", token=alice)
pruefe("alte Sitzung abgemeldet", code == 401, antwort)
code, antwort = s.api("anmelden", login="alice", passwort="neuespasswort1")
alice = antwort.get("token")
pruefe("Anmeldung mit neuem Passwort", bool(alice), antwort)
print("Verwaltung")
jar = http.cookiejar.CookieJar()
oeffner = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))
def csrf(html):
treffer = re.search(rb'name="csrf" value="([0-9a-f]+)"', html)
return treffer.group(1).decode() if treffer else ""
admin_token = urllib.parse.parse_qs(urllib.parse.urlparse(admin_link).query)["t"][0]
code, html, _ = s.roh("/konto/passwort.php", {"t": admin_token, "passwort": "adminpasswort99",
"wiederholung": "adminpasswort99"})
pruefe("Admin-Passwort über Einrichtungslink gesetzt", "Zur Verwaltung" in html.decode())
code, html, _ = s.roh("/verwaltung/", oeffner=oeffner)
pruefe("Verwaltung fordert Anmeldung", "Anmelden" in html.decode())
code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "info@tyrveil.com", "passwort": "falsch",
"csrf": csrf(html)}, oeffner=oeffner)
pruefe("falsches Admin-Passwort", "stimmt nicht" in html.decode())
code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "alice@example.org",
"passwort": "neuespasswort1", "csrf": csrf(html)}, oeffner=oeffner)
pruefe("normaler Nutzer kommt nicht in die Verwaltung", "stimmt nicht" in html.decode())
code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "info@tyrveil.com",
"passwort": "adminpasswort99", "csrf": csrf(html)}, oeffner=oeffner)
pruefe("Admin angemeldet, Übersicht", code == 200 and "Offene Einladungen" in html.decode(), html[-300:])
for seite, erwartet in (("nutzer", "alice@example.org"), ("charaktere", "Nordlicht"), ("squads", "Squads"),
(f"charakter&id={nordlicht['id']}", "ROHDATEN")):
code, html, _ = s.roh(f"/verwaltung/?seite={seite}", oeffner=oeffner)
pruefe(f"Seite {seite.split('&')[0]}", code == 200 and erwartet in html.decode(), code)
code, bild, kopf = s.roh(f"/verwaltung/?seite=bild&id={nordlicht['id']}", oeffner=oeffner)
pruefe("Porträt in der Verwaltung", code == 200 and kopf.get("Content-Type") == "image/png", code)
code, html, _ = s.roh("/verwaltung/?seite=nutzer", oeffner=oeffner)
bob_id = s_nutzer_id(html, "bob@example.org")
code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_sperren", "id": bob_id}, oeffner=oeffner)
pruefe("ohne CSRF-Token abgewiesen", "abgelaufen" in html.decode())
code, html, _ = s.roh("/verwaltung/?seite=nutzer", oeffner=oeffner)
code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_sperren", "id": bob_id, "csrf": csrf(html)},
oeffner=oeffner)
pruefe("Bob gesperrt", "gesperrt und abgemeldet" in html.decode())
code, antwort = s.api("ich", token=bob)
pruefe("Bobs Sitzung ungültig", code == 401, antwort)
code, antwort = s.api("anmelden", login="bob", passwort="bobpasswort12")
pruefe("Bob kann sich nicht anmelden", antwort.get("fehler") == "gesperrt", antwort)
code, html, _ = s.roh(f"/verwaltung/?seite=bestaetigen&aktion=nutzer_loeschen&id={bob_id}", oeffner=oeffner)
pruefe("Löschen zeigt Bestätigungsseite", "Ja, ausführen" in html.decode() and "bob" in html.decode())
code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_loeschen", "id": bob_id, "csrf": csrf(html)},
oeffner=oeffner)
pruefe("Bob gelöscht", "gelöscht" in html.decode() and "bob@example.org" not in html.decode())
print("Konto und Bremse")
code, antwort = s.api("konto_loeschen", token=alice, passwort="falsch")
pruefe("Konto löschen braucht Passwort", antwort.get("fehler") == "anmeldung_falsch", antwort)
code, antwort = s.api("konto_loeschen", token=alice, passwort="neuespasswort1")
pruefe("Alice löscht ihr Konto", code == 200, antwort)
portraets = list((s.daten / "portraets").glob("*.png"))
pruefe("Porträtdateien mitgelöscht", portraets == [], portraets)
antworten = [s.api("anmelden", login="niemand", passwort="falsch-falsch")[1].get("fehler") for _ in range(11)]
pruefe("nach 10 Fehlversuchen: zu_viele_versuche", antworten[-1] == "zu_viele_versuche", antworten)
def s_nutzer_id(html, email):
zeilen = html.decode().split("<tr>")
for zeile in zeilen:
if email in zeile:
treffer = re.search(r'name="id" value="(\d+)"', zeile)
if treffer:
return treffer.group(1)
return "0"
if __name__ == "__main__":
main()