Richard/Deploymentcenter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(2.9.0): Hardwarekey an der WebUI-Anmeldung und die Roadmap als Tafel

Browse Source 
Zwei angeforderte Funktionen, dazu zwei Befunde, die ihnen im Weg lagen.

== Zweite Stufe der Anmeldung (#666) ==
Nach korrektem Passwort verlangt das WebUI einen registrierten FIDO2-Schluessel.
Die Pflicht haengt je Konto daran, OB ein Schluessel registriert ist - nicht an
einem Schalter. Ein Schalter, den man vor der Registrierung umlegt, sperrt den
Betreiber aus seiner eigenen Verwaltung aus.

Ohne Fremdbibliothek gebaut (das Projekt hat bewusst kein Composer):
src/Core/Webauthn/ mit CBOR-Leser, COSE-nach-DER-Wandlung und Pruefung ueber
openssl_verify (ES256, RS256). Auth::login() heisst jetzt Auth::startLogin()
und liefert drei Zustaende statt eines bool - aus "wahr heisst drin" ist "wahr
heisst vielleicht drin" geworden, und ein uebersehener Aufrufer soll an einem
fehlenden Methodennamen scheitern statt an einer truthy Zeichenkette. Die
Setup-API der Zielsysteme geht ueber verifyCredentials() daran vorbei und
bleibt unberuehrt.

Notfalltoken als Ersatzweg: nur als Hash in der Datenbank, Klartext einmalig
angezeigt, Einmalgebrauch. Laeuft als gewoehnliches Formular ohne JavaScript -
ein Ersatzweg mit denselben Voraussetzungen wie der Hauptweg waere keiner.
Fehlversuche auf der zweiten Stufe laufen in dieselbe Konto- und IP-Sperre wie
das Passwort; zuvor zaehlte nur die erste Stufe.

Benutzerverwaltung kann Konten umbenennen. Beim Loeschen eines Kontos und beim
Zuruecksetzen der Testinstanz werden seine Schluessel mitgenommen: credential_id
ist geraeteweit eindeutig, eine verwaiste Zeile haette denselben Yubikey
dauerhaft unbrauchbar gemacht.

== Roadmap-Tafel (#664) ==
Neuer Unterreiter Roadmap -> Tafel. Der Server liefert die fertige Gliederung
(RoadmapBoard, ?action=board), die Seite rendert nur - sonst schneidet das
WebUI anders als die API und ein spaeterer Export ein drittes Mal anders.

Phasen stehen nicht im Code: gepflegt in der neuen Tabelle roadmap_phases,
sonst an den groessten Luecken der Rangfolge geschnitten und sichtbar als
geraten gekennzeichnet. Links die gekappte Spalte des Erledigten, rechts
"Wird ueberlegt". Nachpruefung ist ein eigener Zustand und wird nicht als
erledigt gezeichnet.

Klick oeffnet ein Seitenpanel: Volltext, Verlauf, Kommentieren mit
action_taken, Aendern von Bereich, Rang, Zielfassung, Status und Ausloeser -
ohne Seitenwechsel. Das war der eigentliche Gewinn: Wer etwas bemerkte, musste
sich bisher die Nummer merken und im Bugtracker danach suchen. Tiefe Verweise
#roadmap/<projekt>/item/<id>. Ziehen zwischen Phasen ueber ?action=rank_between.

Fremdtext wird ausschliesslich ueber textContent gesetzt, nie ueber innerHTML.

== Befund: roadmap_rank war projektweit und bereichslokal zugleich (#177) ==
Entschieden: projektweit. move() sucht den Nachbarn ohne Bereichsfilter,
reorder() schreibt keinen ganzen Bereich mehr auf 10/20/30 um, sondern
vertauscht nur die Raenge, die die Eintraege ohnehin halten. rank_between
rechnet die Mitte zwischen zwei Nachbarn und nummeriert nur dann einmal neu -
unter Erhalt der Reihenfolge -, wenn dort kein Platz mehr ist; die Antwort
sagt es dann.

== Befund: CSRF an sitzungsauthentifizierten API-Schreibzugriffen ==
ApiAuth akzeptiert die WebUI-Sitzung, die Endpunkte prueften dabei kein
CSRF-Token. Der Kommentar in Http::beginJson - "ausschliesslich per
Token-Header, niemals per Cookie" - traf auf die API nie zu. Schreibende
Anfragen im Sitzungsweg verlangen jetzt csrf_token bzw. X-CSRF-Token.
Token-Clients sind nicht betroffen und wurden gegengeprueft.

== Geprueft ==
tests/e2e/suite_tafel.py neu (16 Faelle), Suite gesamt 172 von 172 gegen die
Testinstanz. Die WebAuthn-Zeremonien zusaetzlich gegen einen Software-
Authenticator mit echtem P-256 und echtem CBOR: Registrieren, Anmelden,
verfaelschte Signatur, veraltete Herausforderung und Zaehler-Rueckfall als
Klonverdacht werden je mit 403 abgewiesen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Deploymentcenter Bot
2026-09-20 18:16:51 +02:00
co-authored by Claude Opus 5
parent edea46e342
commit f0ed67ad29
22 changed files with 4996 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files
public/api/auth/v1/index.php
+248
View File
@@ -0,0 +1,248 @@
<?php
/**
* /api/auth/v1/...
*
* Die beiden WebAuthn-Zeremonien als JSON-Endpunkt. Der Browser kann
* navigator.credentials nicht aus einem Formular heraus bedienen - er braucht
* die Vorgaben als JSON und schickt die Antwort ebenso zurueck.
*
* POST ?action=login_options Vorgaben fuer get() (Zwischenzustand)
* POST ?action=login_verify Antwort auf get() (Zwischenzustand)
* POST ?action=register_options Vorgaben fuer create() (angemeldet)
* POST ?action=register_verify Antwort auf create() (angemeldet)
*
* Bewusst NICHT ueber ApiAuth: Zwei der vier Aktionen laufen in einem
* Zustand, in dem noch niemand angemeldet ist. Sie an eine Klasse zu haengen,
* deren Aufgabe "authentifiziert oder 401" ist, hiesse, ihr eine Ausnahme
* beizubringen - und Ausnahmen in der Authentifizierung sind genau die
* Stellen, an denen man sich spaeter vertut.
*
* Der Notfalltoken laeuft nicht hier, sondern als gewoehnliches Formular in
* login.php. Er soll auch dann funktionieren, wenn JavaScript nicht laeuft -
* ein Ersatzweg, der dieselben Voraussetzungen hat wie der Hauptweg, ist
* keiner.
*/
declare(strict_types=1);
require_once __DIR__ . '/../../../../src/bootstrap.php';
use Deploymentcenter\Core\Auth;
use Deploymentcenter\Core\Csrf;
use Deploymentcenter\Core\Db;
use Deploymentcenter\Core\Http;
use Deploymentcenter\Core\Logger;
use Deploymentcenter\Core\SecurityLogger;
use Deploymentcenter\Core\Webauthn\CredentialRepo;
use Deploymentcenter\Core\Webauthn\WebauthnServer;
// Kein publicCors: Diese Endpunkte arbeiten mit dem Sitzungscookie. Ein
// "Access-Control-Allow-Origin: *" waere hier das Gegenteil dessen, was
// gemeint ist.
Http::beginJson(['POST', 'OPTIONS'], false);
Auth::startSession();
$action = strtolower(Http::str('action') ?? '');
if (Http::method() !== 'POST') {
Http::fail(405, 'method_not_allowed', 'Dieser Endpunkt erwartet POST.');
}
$db = Db::init();
$repo = new CredentialRepo($db);
switch ($action) {
// -----------------------------------------------------------------
// Anmelden, zweite Stufe
// -----------------------------------------------------------------
case 'login_options': {
$userId = Auth::pendingUserId();
if ($userId <= 0) {
Http::fail(401, 'no_pending_login', 'Es steht keine Anmeldung offen. Bitte von vorn beginnen.');
}
$ids = $repo->rawIdsForUser($userId);
if ($ids === []) {
Http::fail(409, 'no_credentials', 'Fuer dieses Konto ist kein Hardwarekey hinterlegt.');
}
$challenge = WebauthnServer::challenge();
Auth::storeChallenge($challenge);
Http::ok(['publicKey' => WebauthnServer::assertionOptions($challenge, $ids)]);
break;
}
case 'login_verify': {
$userId = Auth::pendingUserId();
if ($userId <= 0) {
Http::fail(401, 'no_pending_login', 'Es steht keine Anmeldung offen. Bitte von vorn beginnen.');
}
$challenge = Auth::takeChallenge();
if ($challenge === '') {
Http::fail(400, 'challenge_expired', 'Die Anfrage ist abgelaufen. Bitte erneut versuchen.');
}
$credentialId = WebauthnServer::b64uDecode((string)Http::str('id', ''));
$clientDataJson = WebauthnServer::b64uDecode((string)Http::str('clientDataJSON', ''));
$authenticatorRaw = WebauthnServer::b64uDecode((string)Http::str('authenticatorData', ''));
$signature = WebauthnServer::b64uDecode((string)Http::str('signature', ''));
if ($credentialId === '' || $clientDataJson === '' || $authenticatorRaw === '' || $signature === '') {
Http::fail(400, 'incomplete', 'Die Antwort des Browsers ist unvollstaendig.');
}
$credential = $repo->find($userId, $credentialId);
if ($credential === null) {
// Der Schluessel gehoert nicht zu diesem Konto. Das ist kein
// Bedienfehler, das ist ein Fehlversuch - und zaehlt als solcher.
Auth::recordSecondFactorFailure($db, 'unknown_credential');
Http::fail(403, 'unknown_credential', 'Dieser Hardwarekey ist fuer das Konto nicht hinterlegt.');
}
try {
$result = WebauthnServer::verifyAssertion(
$clientDataJson,
$authenticatorRaw,
$signature,
$challenge,
(string)$credential['public_key'],
(int)$credential['alg'],
(int)$credential['sign_count']
);
} catch (\Throwable $e) {
Auth::recordSecondFactorFailure($db, 'assertion_rejected');
Logger::warning('Hardwarekey abgelehnt', [
'user_id' => $userId,
'error' => $e->getMessage(),
]);
Http::fail(403, 'assertion_rejected', $e->getMessage());
}
$repo->touch((int)$credential['id'], $result['sign_count']);
if (!Auth::completeSecondFactor($db, 'hardware_key')) {
Http::fail(403, 'login_failed', 'Die Anmeldung konnte nicht abgeschlossen werden.');
}
Http::ok(['redirect' => '/index.php']);
break;
}
// -----------------------------------------------------------------
// Registrieren - nur aus einer bestehenden Anmeldung heraus
// -----------------------------------------------------------------
case 'register_options': {
if (!Auth::isLoggedIn()) {
Http::fail(401, 'unauthorized', 'Anmeldung erforderlich.');
}
Csrf::requireValid();
$userId = Auth::userId();
$challenge = WebauthnServer::challenge();
Auth::storeChallenge($challenge);
Http::ok([
'publicKey' => WebauthnServer::registrationOptions(
$challenge,
$userId,
Auth::username(),
$repo->rawIdsForUser($userId)
),
]);
break;
}
case 'register_verify': {
if (!Auth::isLoggedIn()) {
Http::fail(401, 'unauthorized', 'Anmeldung erforderlich.');
}
Csrf::requireValid();
$userId = Auth::userId();
$challenge = Auth::takeChallenge();
if ($challenge === '') {
Http::fail(400, 'challenge_expired', 'Die Anfrage ist abgelaufen. Bitte erneut versuchen.');
}
$clientDataJson = WebauthnServer::b64uDecode((string)Http::str('clientDataJSON', ''));
$attestationObject = WebauthnServer::b64uDecode((string)Http::str('attestationObject', ''));
if ($clientDataJson === '' || $attestationObject === '') {
Http::fail(400, 'incomplete', 'Die Antwort des Browsers ist unvollstaendig.');
}
$label = Http::str('label') ?? 'Hardwarekey';
$label = mb_substr(trim($label), 0, 64);
if ($label === '') {
$label = 'Hardwarekey';
}
$transports = Http::input('transports');
$transports = is_array($transports)
? mb_substr(implode(',', array_map('strval', $transports)), 0, 128)
: null;
try {
$registration = WebauthnServer::verifyRegistration($clientDataJson, $attestationObject, $challenge);
} catch (\Throwable $e) {
Logger::warning('Registrierung eines Hardwarekeys abgelehnt', [
'user_id' => $userId,
'error' => $e->getMessage(),
]);
Http::fail(400, 'registration_rejected', $e->getMessage());
}
if ($repo->find($userId, $registration['credential_id']) !== null) {
Http::fail(409, 'already_registered', 'Dieser Hardwarekey ist bereits hinterlegt.');
}
try {
$repo->add(
$userId,
$registration['credential_id'],
$registration['public_key'],
$registration['alg'],
$registration['sign_count'],
$registration['aaguid'],
$label,
$transports
);
} catch (\PDOException $e) {
// Eindeutiger Schluessel verletzt: derselbe Key an einem anderen
// Konto. Die Kennung ist geraeteweit eindeutig, deshalb faellt
// das hier und nicht in der Suche oben auf.
if ((string)$e->getCode() === '23000') {
Http::fail(409, 'already_registered', 'Dieser Hardwarekey ist bereits einem Konto zugeordnet.');
}
throw $e;
}
// Ein neuer zweiter Faktor am eigenen Konto gehoert ins
// Sicherheitsprotokoll - es ist die Aenderung, die im Ernstfall die
// Frage beantwortet, seit wann ein fremder Schluessel mitliest.
SecurityLogger::log('credential_registered', Http::clientIp(), [
'username' => Auth::username(),
'label' => $label,
]);
Http::ok([
'label' => $label,
'total' => $repo->countForUser($userId),
'message' => 'Hardwarekey registriert.',
]);
break;
}
default:
Http::fail(404, 'unknown_action', sprintf('Unbekannte Aktion "%s".', $action), null, [
'available' => ['login_options', 'login_verify', 'register_options', 'register_verify'],
]);
}
public/api/bugtracker/v1/roadmap.php
+78 -3
View File
@@ -31,11 +31,12 @@ use Deploymentcenter\Core\Db;
use Deploymentcenter\Core\Http;
use Deploymentcenter\Modules\Bugtracker\BugRepo;
use Deploymentcenter\Modules\Bugtracker\Roadmap;
use Deploymentcenter\Modules\Bugtracker\RoadmapBoard;
Http::beginJson(['GET', 'POST', 'OPTIONS'], true);
const READ_ACTIONS = ['list', 'epics', 'next', 'active', 'render', 'check'];
const WRITE_ACTIONS = ['set', 'move', 'reorder', 'epic'];
const READ_ACTIONS = ['list', 'epics', 'next', 'active', 'render', 'check', 'board'];
const WRITE_ACTIONS = ['set', 'move', 'reorder', 'epic', 'rank_between'];
$action = strtolower(Http::str('action') ?? 'list');
@@ -98,6 +99,20 @@ switch ($action) {
'items' => $roadmap->activeWork($scope),
]);
case 'board': {
// Die fertige Gliederung der Tafel: Spalten, Spuren, Kaertchen.
//
// Ein Projekt, nicht "alle": Die Phasen werden aus roadmap_rank
// geschnitten, und der Rang gilt je Projekt. Zwei Projekte
// uebereinanderzulegen ergaebe Spalten, die in keinem von beiden
// stimmen.
$project = requireProject($scope, $context);
Http::ok((new RoadmapBoard($db))->build($project, [
'done_limit' => Http::int('done_limit', RoadmapBoard::DONE_LIMIT),
]));
}
case 'render': {
$project = requireProject($scope, $context);
Http::ok([
@@ -245,6 +260,60 @@ switch ($action) {
Http::ok(['message' => sprintf('#%d verschoben.', $itemId)]);
}
case 'rank_between': {
// Das Ziehen auf der Tafel. Der Aufrufer sagt, zwischen welche
// beiden Nachbarn der Eintrag gehoert; den Rang rechnet der Server
// aus. Andersherum - der Client schickt einen fertigen Rang - waere
// die Rangvergabe an zwei Stellen umgesetzt, und die zweite wuesste
// nichts von #177.
$itemId = Http::int('id', 0) ?: 0;
if ($itemId < 1) {
Http::fail(400, 'missing_id', 'Das Feld "id" fehlt.');
}
assertOwnProject($repo, $writeProject, $itemId);
$prevId = Http::input('prev_id') !== null ? Http::int('prev_id', 0) : null;
$nextId = Http::input('next_id') !== null ? Http::int('next_id', 0) : null;
$minRank = Http::input('min_rank') !== null ? Http::int('min_rank', 0) : null;
$maxRank = Http::input('max_rank') !== null ? Http::int('max_rank', 0) : null;
try {
$result = $roadmap->rankBetween(
$itemId,
$prevId !== null && $prevId > 0 ? $prevId : null,
$nextId !== null && $nextId > 0 ? $nextId : null,
$minRank,
$maxRank
);
} catch (\RuntimeException $e) {
Http::fail(409, 'cannot_rank', $e->getMessage());
}
$repo->addComment(
$itemId,
'user:' . $author,
sprintf(
'Reihenfolge auf der Tafel geaendert: Rang %d.%s',
$result['rank'],
$result['renumbered']
? ' Dafuer wurden die Raenge des Projekts einmal neu vergeben (Zehnerschritte) -'
. ' die Reihenfolge blieb dabei erhalten.'
: ''
),
'commented'
);
Http::ok([
'id' => $itemId,
'rank' => $result['rank'],
'renumbered' => $result['renumbered'],
'message' => $result['renumbered']
? sprintf('#%d eingeordnet (Rang %d). Die Raenge des Projekts wurden dabei neu vergeben.', $itemId, $result['rank'])
: sprintf('#%d eingeordnet (Rang %d).', $itemId, $result['rank']),
]);
}
case 'reorder': {
$project = requireProject($writeProject ?? $angefragt, $context);
$epic = Http::str('epic');
@@ -271,12 +340,18 @@ switch ($action) {
Http::fail(400, 'missing_fields', 'Es werden "epic" und "title" erwartet.');
}
// Nicht mitgeschickte Felder bleiben unveraendert - ein Aufruf, der
// nur den Titel richtigstellt, soll nicht die Farbe loeschen.
$highlight = Http::input('highlight');
$roadmap->saveEpic(
$project,
$epic,
$title,
Http::str('summary'),
Http::int('sort_order', 100) ?: 100
Http::int('sort_order', 100) ?: 100,
Http::input('color') !== null ? (string)Http::str('color', '') : null,
$highlight !== null ? (bool)$highlight : null
);
Http::ok(['message' => sprintf('Themenbereich "%s" gespeichert.', $epic)]);
public/api/openapi.php
+94 -5
View File
@@ -422,12 +422,24 @@ $spec = [
. "- `action=active` wer haelt gerade welches Item\n"
. "- `action=render` der erzeugte Markdown-Block fuer die Projektdatei\n"
. "- `action=check` Abgleich einer mitgeschickten Datei (`content`) gegen "
. "die Items\n\n"
. "die Items\n"
. "- `action=board` die fertige Gliederung der Roadmap-Tafel\n\n"
. "`board` liefert `{phases[], lanes[], items[], stats, meta}` fuer genau "
. "EIN Projekt. Die Spalten werden aus `roadmap_rank` geschnitten - "
. "entweder nach den in `roadmap_phases` gepflegten Grenzen oder, wenn "
. "dort nichts steht, an den groessten Luecken der Rangfolge; dann ist "
. "`meta.phases_guessed` wahr und die Grenzen gehoeren als geraten "
. "gekennzeichnet. `done_limit` kappt die Spalte der erledigten Vorhaben "
. "(0 = alle).\n\n"
. "Titel, Beschreibungen und Kommentare in `items` sind Fremdtext von "
. "fremden Maschinen. Sie kommen unveraendert und gehoeren beim Rendern "
. "escaped - niemals als HTML eingesetzt.\n\n"
. "`status` nimmt eine Lage statt eines ENUM-Werts: `aktiv`, `offen`, "
. "`arbeit`, `erledigt`, `zurueckgestellt`, `verworfen`. Einzelstatus "
. "funktionieren weiterhin.",
'parameters' => [
['name' => 'action', 'in' => 'query', 'schema' => ['type' => 'string', 'enum' => ['list', 'epics', 'next', 'active', 'render', 'check'], 'default' => 'list']],
['name' => 'action', 'in' => 'query', 'schema' => ['type' => 'string', 'enum' => ['list', 'epics', 'next', 'active', 'render', 'check', 'board'], 'default' => 'list']],
['name' => 'done_limit', 'in' => 'query', 'schema' => ['type' => 'integer', 'default' => 12], 'description' => 'Nur bei action=board: wie viele erledigte Vorhaben die Fundamentspalte zeigt. 0 = alle.'],
['name' => 'project_slug', 'in' => 'query', 'schema' => ['type' => 'string']],
['name' => 'epic', 'in' => 'query', 'schema' => ['type' => 'string'], 'description' => 'Themenbereich, z. B. "A"'],
['name' => 'status', 'in' => 'query', 'schema' => ['type' => 'string'], 'description' => 'Lage oder kommagetrennte Einzelstatus'],
@@ -447,13 +459,26 @@ $spec = [
. "- `action=set&id=` setzt `epic`, `roadmap_rank`, `target_build`, "
. "`defer_trigger`, `doc_anchor` und optional `status`\n"
. "- `action=move&id=` schiebt einen Eintrag eine Position (`direction=up|down`)\n"
. "- `action=reorder` vergibt die Reihenfolge eines Bereichs neu (`epic`, `ids[]`)\n"
. "- `action=epic` legt einen Themenbereich an oder aendert ihn\n\n"
. "- `action=reorder` ordnet die Eintraege eines Bereichs untereinander neu (`epic`, `ids[]`)\n"
. "- `action=rank_between&id=` sortiert einen Eintrag zwischen zwei Nachbarn ein\n"
. "- `action=epic` legt einen Themenbereich an oder aendert ihn "
. "(`color`, `highlight` steuern die Spur auf der Tafel; nicht "
. "mitgeschickte Felder bleiben unveraendert)\n\n"
. "**`roadmap_rank` gilt PROJEKTWEIT, nicht je Bereich.** `action=next` "
. "sortiert danach ohne Gruppierung, und die Tafel schneidet ihre Phasen "
. "daraus. `move` sucht den Nachbarn deshalb projektweit, und `reorder` "
. "vertauscht nur die Raenge, die die genannten Eintraege ohnehin halten - "
. "es zaehlt nicht mehr je Bereich bei 10 neu durch.\n\n"
. "`rank_between` nimmt `prev_id` und `next_id` (beide optional) und "
. "setzt den Eintrag auf die Mitte dazwischen; fuer eine leere Zielspalte "
. "tun es `min_rank`/`max_rank`. Ist zwischen den Nachbarn kein Platz "
. "mehr, wird das Projekt EINMAL neu durchnummeriert - die Reihenfolge "
. "bleibt dabei erhalten, und die Antwort sagt es mit `renumbered: true`.\n\n"
. "**Zurueckstellen verlangt einen Ausloeser.** `status=deferred` ohne "
. "`defer_trigger` wird mit 400 abgelehnt: Ohne benannten Anlass ist ein "
. "Vorhaben nicht zurueckgestellt, sondern vergessen.",
'parameters' => [
['name' => 'action', 'in' => 'query', 'required' => true, 'schema' => ['type' => 'string', 'enum' => ['set', 'move', 'reorder', 'epic']]],
['name' => 'action', 'in' => 'query', 'required' => true, 'schema' => ['type' => 'string', 'enum' => ['set', 'move', 'reorder', 'rank_between', 'epic']]],
['name' => 'id', 'in' => 'query', 'schema' => ['type' => 'integer']],
],
'responses' => [
@@ -784,6 +809,70 @@ $spec = [
],
],
'/api/auth/v1/' => [
'post' => [
'tags' => ['Setup'],
'summary' => 'WebAuthn-Zeremonien der WebUI-Anmeldung',
'description' =>
"Die zweite Stufe der Anmeldung am WebUI: ein Hardwarekey (FIDO2/WebAuthn).\n\n"
. "**Dieser Endpunkt ist nichts fuer Agenten und Clients.** Er arbeitet mit dem "
. "Sitzungscookie des Browsers, nicht mit einem Token, und ist nur deshalb hier "
. "beschrieben, weil `navigator.credentials` sich nicht aus einem Formular "
. "heraus bedienen laesst.\n\n"
. "Vier Aktionen ueber `?action=`:\n"
. "- `login_options` / `login_verify` - laufen im Zwischenzustand zwischen "
. "Passwort und zweitem Faktor. Noch ist niemand angemeldet.\n"
. "- `register_options` / `register_verify` - setzen eine bestehende Anmeldung "
. "voraus und verlangen zusaetzlich ein CSRF-Token im Kopf `X-CSRF-Token`.\n\n"
. "Ein registrierter Schluessel gilt nur fuer die Adresse, unter der er "
. "registriert wurde. Ein Schluessel von `dc.mhdf.de` ist auf der Testinstanz "
. "wertlos und umgekehrt - das ist der Kern des Verfahrens und kein Mangel.\n\n"
. "Der Ersatzweg fuer einen fehlenden Schluessel ist der Notfalltoken; der "
. "laeuft als gewoehnliches Formular ueber `/login.php` und braucht kein "
. "JavaScript.",
'security' => [],
'parameters' => [
['name' => 'action', 'in' => 'query', 'required' => true,
'schema' => ['type' => 'string', 'enum' => [
'login_options', 'login_verify', 'register_options', 'register_verify',
]]],
],
'requestBody' => [
'required' => false,
'content' => ['application/json' => ['schema' => [
'type' => 'object',
'description' => 'Je nach Aktion. Alle Bytefelder sind base64url ohne Auffuellzeichen.',
'properties' => [
'id' => ['type' => 'string', 'description' => 'login_verify: Kennung des benutzten Schluessels.'],
'clientDataJSON' => ['type' => 'string'],
'authenticatorData' => ['type' => 'string', 'description' => 'nur login_verify'],
'signature' => ['type' => 'string', 'description' => 'nur login_verify'],
'attestationObject' => ['type' => 'string', 'description' => 'nur register_verify'],
'label' => ['type' => 'string', 'description' => 'register_verify: Bezeichnung des Schluessels.'],
'transports' => ['type' => 'array', 'items' => ['type' => 'string']],
],
]]],
],
'responses' => [
'200' => [
'description' => 'Vorgaben fuer den Browser, oder die bestaetigte Zeremonie',
'content' => ['application/json' => ['schema' => [
'type' => 'object',
'properties' => [
'publicKey' => ['type' => 'object', 'description' => 'Bei den *_options-Aktionen: direkt an navigator.credentials weiterzureichen.'],
'redirect' => ['type' => 'string', 'description' => 'Bei login_verify: wohin der Browser danach gehoert.'],
],
]]],
],
'400' => $errorResponse,
'401' => $errorResponse,
'403' => $errorResponse,
'409' => $errorResponse,
'419' => $errorResponse,
],
],
],
'/api/setup/v1/catalog' => [
'get' => [
'tags' => ['Setup'],