Der Squad-Reiter braucht kein Konto mehr: Spielername eingeben, der PC
bekommt einen Schluessel (Token ohne Ablauf), die Akten werden fuer alle
sichtbar. E-Mail und Passwort sind optional ("Konto sichern") und machen
die Charaktere reset- und mehr-PC-fest. Ohne gesichertes Konto bietet das
Menue kein Abmelden, weil das den Schluessel loeschte.
Server: Aktionen mitmachen und konto_sichern, Konten ohne E-Mail
(Datenbank-Stand 2, eingespielt von DB::migrieren() bei der ersten
Anfrage), Loeschen ohne Passwort fuer reine Schluessel-Konten, Verwaltung
zeigt sie als "nur Schluessel". Deinstallationsfrage nennt den Schluessel.
Tests: Server 108, Zwei-PC 34, Oberflaeche 24 - auch gegen das Paket.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
292 lines
14 KiB
PHP
292 lines
14 KiB
PHP
<?php
|
||
/*
|
||
* Nutzerkonten: Registrierung mit E-Mail-Bestaetigung, Anmeldung,
|
||
* Passwort vergessen, Konto loeschen.
|
||
*/
|
||
declare(strict_types=1);
|
||
|
||
final class Konten
|
||
{
|
||
/** Laufzeit des Schluessels eines PCs ohne Konto: praktisch unbegrenzt. */
|
||
public const SCHLUESSEL_TAGE = 36500;
|
||
|
||
public static function oeffentlich(array $nutzer): array
|
||
{
|
||
return [
|
||
'id' => (int) $nutzer['id'],
|
||
'benutzername' => $nutzer['benutzername'],
|
||
'email' => $nutzer['email'],
|
||
'rolle' => $nutzer['rolle'],
|
||
// false: nur der Schluessel dieses PCs, keine E-Mail und kein Passwort
|
||
'gesichert' => $nutzer['email'] !== null,
|
||
'bestaetigt' => $nutzer['email_bestaetigt_am'] !== null,
|
||
];
|
||
}
|
||
|
||
private static function namePruefen(string $name, string $was = 'Der Benutzername'): string
|
||
{
|
||
$name = trim($name);
|
||
if (!preg_match('/^[A-Za-z0-9_.-]{3,32}$/', $name)) {
|
||
throw new SmFehler('benutzername_ungueltig', "$was braucht 3 bis 32 Zeichen: "
|
||
. 'Buchstaben, Ziffern, Punkt, Minus oder Unterstrich.');
|
||
}
|
||
return $name;
|
||
}
|
||
|
||
/**
|
||
* Mitmachen ohne Konto: legt einen Nutzer nur mit Spielernamen an. Das
|
||
* Token ist der Schluessel des PCs und laeuft nicht ab. Wer ihn verliert,
|
||
* kann seine Charaktere nicht mehr bearbeiten - ausser er hat das Konto
|
||
* vorher mit E-Mail und Passwort gesichert.
|
||
*/
|
||
public static function mitmachen(string $spielername, string $geraet): array
|
||
{
|
||
$name = self::namePruefen($spielername, 'Der Spielername');
|
||
Sicherheit::bremseOderFehler('mitmachen', Sicherheit::ip(), 5, 3600);
|
||
if (DB::wert('SELECT 1 FROM sm_nutzer WHERE benutzername_klein = ?', [mb_strtolower($name)])) {
|
||
throw new SmFehler('benutzername_vergeben', 'Diesen Spielernamen gibt es schon.', 409);
|
||
}
|
||
try {
|
||
$id = DB::einfuegen('sm_nutzer', [
|
||
'benutzername' => $name,
|
||
'benutzername_klein' => mb_strtolower($name),
|
||
'email' => null,
|
||
'passwort_hash' => null,
|
||
'rolle' => 'nutzer',
|
||
'gesperrt' => 0,
|
||
'erstellt_am' => DB::jetzt(),
|
||
'letzte_anmeldung_am' => DB::jetzt(),
|
||
]);
|
||
} catch (PDOException $fehler) {
|
||
if ((string) $fehler->getCode() === '23000') {
|
||
throw new SmFehler('benutzername_vergeben', 'Diesen Spielernamen gibt es schon.', 409);
|
||
}
|
||
throw $fehler;
|
||
}
|
||
$token = Sicherheit::tokenAnlegen($id, 'sitzung', self::SCHLUESSEL_TAGE * 86400, $geraet);
|
||
return ['token' => $token,
|
||
'nutzer' => self::oeffentlich(DB::eine('SELECT * FROM sm_nutzer WHERE id = ?', [$id]))];
|
||
}
|
||
|
||
/** Haengt E-Mail und Passwort an ein Konto, das bisher nur den Schluessel des PCs hatte. */
|
||
public static function kontoSichern(array $nutzer, string $email, string $passwort): array
|
||
{
|
||
if ($nutzer['email'] !== null) {
|
||
throw new SmFehler('schon_gesichert', 'Dieses Konto ist schon mit einer E-Mail-Adresse gesichert.', 409);
|
||
}
|
||
$email = mb_strtolower(trim($email));
|
||
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('sichern', Sicherheit::ip(), 5, 3600);
|
||
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.', 409);
|
||
}
|
||
try {
|
||
DB::aktualisieren('sm_nutzer', ['email' => $email, 'passwort_hash' => Sicherheit::passwortHash($passwort)],
|
||
'id = ? AND email IS NULL', [$nutzer['id']]);
|
||
} catch (PDOException $fehler) {
|
||
if ((string) $fehler->getCode() === '23000') {
|
||
throw new SmFehler('email_vergeben', 'Mit dieser E-Mail-Adresse gibt es schon ein Konto.', 409);
|
||
}
|
||
throw $fehler;
|
||
}
|
||
self::bestaetigungSenden((int) $nutzer['id'], $nutzer['benutzername'], $email);
|
||
return self::oeffentlich(DB::eine('SELECT * FROM sm_nutzer WHERE id = ?', [$nutzer['id']]));
|
||
}
|
||
|
||
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
|
||
{
|
||
// Ohne Passwort (nur Schluessel) ist der Schluessel selbst der Nachweis
|
||
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]);
|
||
});
|
||
}
|
||
}
|