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:
parent
58a3573fd6
commit
6e4d4afc1d
23 changed files with 2872 additions and 1 deletions
4
.gitignore
vendored
4
.gitignore
vendored
|
|
@ -9,3 +9,7 @@ __pycache__/
|
|||
# Editor
|
||||
.idea/
|
||||
.vscode/
|
||||
|
||||
# Server: Zugangsdaten und Nutzerdaten nie ins Repository
|
||||
server/sva-privat/config.php
|
||||
server/sva-privat/daten/
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
166
server/sva-privat/app/api.php
Normal file
166
server/sva-privat/app/api.php
Normal 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);
|
||||
}
|
||||
}
|
||||
314
server/sva-privat/app/charaktere.php
Normal file
314
server/sva-privat/app/charaktere.php
Normal 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()];
|
||||
}
|
||||
}
|
||||
236
server/sva-privat/app/db.php
Normal file
236
server/sva-privat/app/db.php
Normal 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);
|
||||
}
|
||||
}
|
||||
209
server/sva-privat/app/konten.php
Normal file
209
server/sva-privat/app/konten.php
Normal 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]);
|
||||
});
|
||||
}
|
||||
}
|
||||
121
server/sva-privat/app/mail.php
Normal file
121
server/sva-privat/app/mail.php
Normal 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');
|
||||
}
|
||||
}
|
||||
144
server/sva-privat/app/sicherheit.php
Normal file
144
server/sva-privat/app/sicherheit.php
Normal 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()]);
|
||||
}
|
||||
}
|
||||
317
server/sva-privat/app/squads.php
Normal file
317
server/sva-privat/app/squads.php
Normal 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);
|
||||
}
|
||||
}
|
||||
75
server/sva-privat/app/start.php
Normal file
75
server/sva-privat/app/start.php
Normal 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);
|
||||
393
server/sva-privat/app/verwaltung.php
Normal file
393
server/sva-privat/app/verwaltung.php
Normal 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&aktion=' . Web::e($aktion) . '&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&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&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;
|
||||
}
|
||||
}
|
||||
110
server/sva-privat/app/web.php
Normal file
110
server/sva-privat/app/web.php
Normal 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;
|
||||
}
|
||||
}
|
||||
46
server/sva-privat/config.beispiel.php
Normal file
46
server/sva-privat/config.beispiel.php
Normal 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,
|
||||
];
|
||||
24
server/sva.tyrveil.com/api/bild.php
Normal file
24
server/sva.tyrveil.com/api/bild.php
Normal 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);
|
||||
5
server/sva.tyrveil.com/api/index.php
Normal file
5
server/sva.tyrveil.com/api/index.php
Normal 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();
|
||||
90
server/sva.tyrveil.com/einrichten.php
Normal file
90
server/sva.tyrveil.com/einrichten.php
Normal 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')));
|
||||
14
server/sva.tyrveil.com/konto/bestaetigen.php
Normal file
14
server/sva.tyrveil.com/konto/bestaetigen.php
Normal 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>');
|
||||
}
|
||||
41
server/sva.tyrveil.com/konto/passwort.php
Normal file
41
server/sva.tyrveil.com/konto/passwort.php
Normal 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>');
|
||||
17
server/sva.tyrveil.com/konto/vergessen.php
Normal file
17
server/sva.tyrveil.com/konto/vergessen.php
Normal 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>');
|
||||
5
server/sva.tyrveil.com/verwaltung/index.php
Normal file
5
server/sva.tyrveil.com/verwaltung/index.php
Normal 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();
|
||||
|
|
@ -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
433
werkzeuge/server_test.py
Normal 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()
|
||||
Loading…
Add table
Add a link
Reference in a new issue