Angemeldet bleiben — und eine 401 reisst nicht mehr die Sitzung ab

Erst die ehrliche Hälfte: dass es heute **andauernd** abgemeldet hat, geht
auf mein Konto. Ich habe die Datenbank dreimal geleert, um mit frischen
Metadaten zu bauen; jedes Mal verfallen alle Token. Kein Schalter der Welt
hätte das verhindert.

Die andere Hälfte ist ein echter Fehler, und er macht aus einem Aussetzer
eine Abmeldung:

**Eine einzelne 401 warf die Anmeldung weg** — und rief dabei
`/auth/logout`, der Server zog das Token also *aktiv zurück*. War die
Ablehnung nur ein Aussetzer, war eine intakte Anmeldung damit absichtlich
zerstört, und zwar unwiderruflich. Jetzt wird einmal nachgefragt: gilt das
Token wirklich nicht mehr, ist die Sitzung vorbei; antwortet der Server, war
es diese eine Anfrage. Mehrere gleichzeitige Anfragen laufen in dieselbe
Prüfung — sonst stellte eine Startseite mit acht Abfragen achtmal dieselbe
Frage. Antwortet der Server **gar nicht**, ist das kein Beleg gegen das
Token: jemanden abzumelden, weil das WLAN hakt, ist der falsche Schluss.

**Abmelden scheitert nie mehr.** Vorher verlangte der Weg eine gültige
Anmeldung — und genau dann, wenn man ihn am dringendsten braucht, gibt es
keine. Nach dem Leeren des Datenbestands zeigte das Cookie im Browser auf
ein Token, das es nicht mehr gab; es ging bei jedem Bild erneut hinaus, und
der Server lehnte es jedes Mal ab. Achtzig Ablehnungen in einer Stunde, und
nichts davon liess sich von aussen beenden. Jetzt wird das Cookie immer
gelöscht; widerrufen wird, was sich widerrufen lässt.

---

**Und der Schalter, um den es ging.** „Angemeldet bleiben" steht jetzt im
Anmeldefeld, mit Haken als Vorgabe — am eigenen Rechner will sich niemand
täglich neu anmelden.

Umgesetzt über die beiden Speicher, die der Browser ohnehin richtig
aufräumt: mit Haken `localStorage` und ein Cookie für ein Jahr, ohne Haken
`sessionStorage` und ein Sitzungscookie, das mit dem Fenster verschwindet.
Ein eigenes Verfallsdatum zu verwalten wäre die schlechtere Variante — eine
Uhr, die man stellen kann, gegen zwei Mechanismen, die es schon gibt.

Das Token selbst läuft weiterhin **nie** ab; es wird widerrufen, nicht
vergessen. Was hier entschieden wird, ist allein, wie lange der Browser sich
erinnert.

372 Tests grün, vier davon neu. Am Container nachgemessen: mit Haken
`max-age=31536000`, ohne Haken kein `max-age`, und ein Abmelden mit
ungültigem Cookie antwortet 204 statt 401.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/tests/Flaro.Api.Tests/WebInterfaceTests.cs

@@ -215,7 +215,95 @@ public sealed class WebInterfaceTests
         }
     }
 
+    /// <summary>„Angemeldet bleiben" entscheidet über die Lebensdauer.</summary>
+    ///
+    /// <remarks>
+    /// Ohne <c>max-age</c> ist es ein Sitzungscookie und verschwindet mit dem
+    /// Browserfenster — richtig an einem fremden Rechner, falsch am eigenen.
+    /// Deshalb wird gefragt statt geraten.
+    /// </remarks>
+    [Test]
+    public async Task Angemeldet_bleiben_setzt_ein_dauerhaftes_Cookie()
+    {
+        using var server = new FlaroServer();
+        await server.SetUpAndSignIn();
+        var client = server.OhneGedaechtnis();
+
+        var dauerhaft = await client.PostAsJsonAsync("/api/v1/auth/login",
+            new LoginRequest("guido", "ein-langes-passwort", "Browser", "b1", StaySignedIn: true));
+        var nurJetzt = await client.PostAsJsonAsync("/api/v1/auth/login",
+            new LoginRequest("guido", "ein-langes-passwort", "Browser", "b1", StaySignedIn: false));
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(GanzerKeks(dauerhaft), Does.Contain("max-age=31536000").IgnoreCase);
+            Assert.That(GanzerKeks(nurJetzt), Does.Not.Contain("max-age").IgnoreCase);
+        });
+    }
+
+    /// <summary>Die Vorgabe ist „bleiben" — ein Client darf es weglassen.</summary>
+    [Test]
+    public async Task Ohne_Angabe_bleibt_man_angemeldet()
+    {
+        using var server = new FlaroServer();
+        await server.SetUpAndSignIn();
+
+        var antwort = await server.OhneGedaechtnis().PostAsJsonAsync("/api/v1/auth/login",
+            new LoginRequest("guido", "ein-langes-passwort", "Browser", "b1"));
+
+        Assert.That(GanzerKeks(antwort), Does.Contain("max-age=31536000").IgnoreCase);
+    }
+
+    /// <summary>Abmelden scheitert nie — auch nicht ohne gültiges Token.</summary>
+    ///
+    /// <remarks>
+    /// <b>Der Fehler dahinter.</b> Vorher verlangte dieser Weg eine gültige
+    /// Anmeldung, und genau dann, wenn man ihn am dringendsten braucht, gibt
+    /// es keine: nach einem geleerten Datenbestand zeigt das Cookie im
+    /// Browser auf ein Token, das es nicht mehr gibt. Es ging bei jedem Bild
+    /// erneut hinaus, der Server lehnte es jedes Mal ab — achtzig
+    /// Ablehnungen in einer Stunde —, und nichts davon liess sich von aussen
+    /// beenden.
+    /// </remarks>
+    [Test]
+    public async Task Abmelden_loescht_das_Cookie_auch_ohne_gueltiges_Token()
+    {
+        using var server = new FlaroServer();
+        await server.SetUpAndSignIn();
+        var client = server.OhneGedaechtnis();
+
+        var anfrage = new HttpRequestMessage(HttpMethod.Post, "/api/v1/auth/logout");
+        anfrage.Headers.Add("Cookie", $"{TokenAuthenticationHandler.CookieName}=laengst-ungueltig");
+        var antwort = await client.SendAsync(anfrage);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(antwort.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
+            // Ein gelöschtes Cookie ist eines mit abgelaufenem Datum.
+            Assert.That(antwort.Headers.GetValues("Set-Cookie").Single(),
+                Does.Contain(TokenAuthenticationHandler.CookieName));
+        });
+    }
+
+    /// <summary>Ein gültiges Token wird dabei trotzdem widerrufen.</summary>
+    [Test]
+    public async Task Abmelden_zieht_ein_gueltiges_Token_weiterhin_zurueck()
+    {
+        using var server = new FlaroServer();
+        var anmeldung = await server.SetUpAndSignIn();
+        var client = server.AlsAngemeldeter(anmeldung.Token);
+
+        (await client.PostAsync("/api/v1/auth/logout", null)).EnsureSuccessStatusCode();
+
+        Assert.That((await client.GetAsync("/api/v1/auth/me")).StatusCode,
+            Is.EqualTo(HttpStatusCode.Unauthorized));
+    }
+
     /// <summary>Nimmt den Namen und den Wert aus der Set-Cookie-Kopfzeile.</summary>
     private static string Keks(HttpResponseMessage antwort) =>
-        antwort.Headers.GetValues("Set-Cookie").Single().Split(';')[0];
+        GanzerKeks(antwort).Split(';')[0];
+
+    /// <summary>Die ganze Kopfzeile — samt Lebensdauer und Schutzangaben.</summary>
+    private static string GanzerKeks(HttpResponseMessage antwort) =>
+        antwort.Headers.GetValues("Set-Cookie").Single();
 }