Adminrecht geben und nehmen — und einen, dem es niemand nimmt

Ein Konto liess sich anlegen und danach nie wieder ändern: kein Weg zum
Administrator, keiner zurück, keiner zum Löschen. Mit Einladungslinks
füllte sich der Server also in genau eine Richtung.

**Warum es einen Besitzer braucht.** Sobald Administratoren einander das
Recht entziehen können, gibt es einen Zustand ohne jeden Administrator —
und aus dem führt kein Weg zurück ausser dem an der Datenbank. Ein Konto,
das ausgenommen ist, schliesst ihn aus. Es ist das erste, also das, mit
dem eingerichtet wurde; die Migration trägt das auf bestehenden Servern
nach, und weil die Kennungen zeitlich geordnet vergeben werden, ist der
Älteste schlicht der mit der kleinsten.

Weitergeben lässt er sich: vom Besitzer, an einen Administrator, mit
Rückfrage. Nur an einen Administrator, sonst wäre der Server einen Klick
von einem Besitzer entfernt, der die Verwaltung gar nicht sieht.

**Drei Türen sind zugemauert**, und jede hat ihren Test: dem Besitzer das
Recht nehmen, den Besitzer löschen, sich selbst das eigene Recht nehmen.
Das letzte ist die unauffälligste — wer sich im Eifer entmachtet, steht
vor einer Verwaltung, die er nicht mehr öffnen kann, und das Zurücknehmen
braucht genau die.

Gemessen und als Test festgehalten: ein frisch vergebenes Adminrecht gilt
**sofort**, ohne neue Anmeldung. Die Rolle wird je Anfrage aus der
Datenbank gelesen und nicht aus dem Token — ich hatte das Gegenteil
befürchtet.

Löschen nimmt mit, was am Konto hing: Geräte, Sehstände, Sehprotokoll,
Meldungen, offene Einladungen. Alles hängt mit `Cascade` daran. Zahlen
über jemanden zu führen, den es nicht mehr gibt, wäre die schlechtere
Hälfte.

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

server/src/Flaro.Api/Endpoints/AuthEndpoints.cs

@@ -91,7 +91,7 @@ public static class AuthEndpoints
 
             return Results.Ok(new AuthenticatedUser(
                 benutzer.Id, benutzer.UserName, benutzer.IsAdministrator,
-                benutzer.Language, benutzer.AvatarImage));
+                benutzer.Language, benutzer.AvatarImage, benutzer.IsOwner));
         }).RequireAuthorization();
 
         MapCodeFlow(app);
@@ -200,7 +200,7 @@ public static class AuthEndpoints
 
         return new LoginResponse(token, new AuthenticatedUser(
             benutzer.Id, benutzer.UserName, benutzer.IsAdministrator,
-            benutzer.Language, benutzer.AvatarImage));
+            benutzer.Language, benutzer.AvatarImage, benutzer.IsOwner));
     }
 
     private const string FlaroTokenCookie = TokenAuthenticationHandler.CookieName;

server/src/Flaro.Api/Endpoints/Contracts.cs

@@ -91,7 +91,16 @@ public sealed record AuthenticatedUser(
     /// auf jeder Seite; es nach der Anmeldung noch einmal holen zu müssen
     /// hiesse, dass der Buchstabenkreis kurz aufblitzt und dann wechselt.
     /// </remarks>
-    string? AvatarImage = null);
+    string? AvatarImage = null,
+
+    /// <summary>Der Besitzer — ihm nimmt niemand das Adminrecht.</summary>
+    ///
+    /// <remarks>
+    /// Hinten angehängt, wie jedes neue Feld in dieser Datei: in der Mitte
+    /// eingeschoben bricht es jede Aufrufstelle, die die Werte der Reihe nach
+    /// übergibt — und davon gibt es hier drei.
+    /// </remarks>
+    bool IsOwner = false);
 
 public sealed record LoginResponse(string Token, AuthenticatedUser User);
 
@@ -109,6 +118,9 @@ public sealed record CodeState(string State, LoginResponse? Login);
 
 public sealed record CreateUserRequest(string UserName, string Password, bool IsAdministrator);
 
+/// <summary>Adminrecht geben oder nehmen.</summary>
+public sealed record RechtRequest(bool IsAdministrator);
+
 /// <summary>Eine Bibliothek, wie die Oberfläche sie zeigt.</summary>
 ///
 /// <remarks>

server/src/Flaro.Api/Endpoints/ManagementEndpoints.cs

@@ -1,3 +1,4 @@
+using System.Security.Claims;
 using Flaro.Api.Auth;
 using Flaro.Core.Libraries;
 using Flaro.Core.Library;
@@ -9,6 +10,9 @@ namespace Flaro.Api.Endpoints;
 
 public static class ManagementEndpoints
 {
+    private static Guid? Kennung(ClaimsPrincipal wer) =>
+        Guid.TryParse(wer.FindFirstValue(ClaimTypes.NameIdentifier), out var id) ? id : null;
+
     public static void MapManagement(this IEndpointRouteBuilder app)
     {
         var benutzer = app.MapGroup("/api/v1/users").RequireAuthorization(FlaroPolicies.Administrator);
@@ -16,9 +20,79 @@ public static class ManagementEndpoints
         benutzer.MapGet("/", async (FlaroContext db) =>
             Results.Ok(await db.Users
                 .OrderBy(u => u.UserName)
-                .Select(u => new AuthenticatedUser(u.Id, u.UserName, u.IsAdministrator))
+                .Select(u => new AuthenticatedUser(
+                    u.Id, u.UserName, u.IsAdministrator, u.Language, u.AvatarImage, u.IsOwner))
                 .ToListAsync()));
 
+        /* ---------- Rechte, Besitz, Löschen ---------- */
+
+        // **Warum es einen Besitzer gibt.** Sobald Administratoren einander
+        // das Recht entziehen können, gibt es einen Zustand ohne jeden
+        // Administrator — und aus dem führt kein Weg zurück ausser dem an der
+        // Datenbank. Ein Konto, das ausgenommen ist, schliesst ihn aus.
+        benutzer.MapPut("/{id:guid}/administrator", async (
+            Guid id, RechtRequest anfrage, ClaimsPrincipal wer,
+            FlaroContext db, CancellationToken ct) =>
+        {
+            var ziel = await db.Users.FirstOrDefaultAsync(u => u.Id == id, ct);
+            if (ziel is null) return Einwand.Fehlt("Dieses Konto gibt es nicht mehr.");
+
+            if (ziel.IsOwner && !anfrage.IsAdministrator)
+                return Einwand.Bitte("Dem Besitzer lässt sich das Adminrecht nicht nehmen.");
+
+            // **Nicht an sich selbst.** Wer sich im Eifer das eigene Recht
+            // nimmt, steht vor einer Verwaltung, die er nicht mehr öffnen
+            // kann — und das Zurücknehmen braucht genau die.
+            if (Kennung(wer) == id && !anfrage.IsAdministrator)
+                return Einwand.Bitte("Das eigene Adminrecht kannst du dir nicht selbst nehmen.");
+
+            ziel.IsAdministrator = anfrage.IsAdministrator;
+            await db.SaveChangesAsync(ct);
+            return Results.NoContent();
+        });
+
+        // **Nur der Besitzer gibt den Besitz weiter**, und nur an jemanden,
+        // der schon Administrator ist: sonst wäre der Server einen Klick von
+        // einem Besitzer entfernt, der die Verwaltung gar nicht sieht.
+        benutzer.MapPost("/{id:guid}/owner", async (
+            Guid id, ClaimsPrincipal wer, FlaroContext db, CancellationToken ct) =>
+        {
+            if (Kennung(wer) is not { } ich) return Results.Unauthorized();
+
+            var bisher = await db.Users.FirstOrDefaultAsync(u => u.Id == ich, ct);
+            if (bisher is not { IsOwner: true })
+                return Einwand.Bitte("Nur der Besitzer kann den Besitz weitergeben.");
+
+            var ziel = await db.Users.FirstOrDefaultAsync(u => u.Id == id, ct);
+            if (ziel is null) return Einwand.Fehlt("Dieses Konto gibt es nicht mehr.");
+            if (!ziel.IsAdministrator)
+                return Einwand.Bitte("Der Besitz geht nur an einen Administrator.");
+
+            bisher.IsOwner = false;
+            ziel.IsOwner = true;
+            await db.SaveChangesAsync(ct);
+            return Results.NoContent();
+        });
+
+        benutzer.MapDelete("/{id:guid}", async (
+            Guid id, ClaimsPrincipal wer, FlaroContext db, CancellationToken ct) =>
+        {
+            var ziel = await db.Users.FirstOrDefaultAsync(u => u.Id == id, ct);
+            if (ziel is null) return Results.NoContent();
+
+            if (ziel.IsOwner) return Einwand.Bitte("Den Besitzer kann man nicht löschen.");
+            if (Kennung(wer) == id)
+                return Einwand.Bitte("Das eigene Konto kannst du hier nicht löschen.");
+
+            // Geräte, Sehstände, Sehprotokoll, Meldungen und offene
+            // Einladungen hängen mit `Cascade` daran — siehe `FlaroContext`.
+            // Ein Konto zu löschen und seine Spuren zu lassen hiesse, Zahlen
+            // über jemanden zu führen, den es nicht mehr gibt.
+            db.Users.Remove(ziel);
+            await db.SaveChangesAsync(ct);
+            return Results.NoContent();
+        });
+
         benutzer.MapPost("/", async (CreateUserRequest anfrage, FlaroContext db) =>
         {
             var name = anfrage.UserName.Trim();

server/src/Flaro.Api/Endpoints/ProfilEndpoints.cs

@@ -46,7 +46,7 @@ public static class ProfilEndpoints
                 ? Results.Unauthorized()
                 : Results.Ok(new AuthenticatedUser(
                     benutzer.Id, benutzer.UserName, benutzer.IsAdministrator,
-                    benutzer.Language, benutzer.AvatarImage));
+                    benutzer.Language, benutzer.AvatarImage, benutzer.IsOwner));
         });
 
         gruppe.MapPost("/avatar", async (

server/src/Flaro.Api/Endpoints/SystemEndpoints.cs

@@ -208,6 +208,10 @@ public static class SystemEndpoints
                     UserName = anfrage.UserName.Trim(),
                     PasswordHash = PasswordHasher.Hash(anfrage.Password),
                     IsAdministrator = true,
+                    // **Wer einrichtet, besitzt.** Ihm nimmt niemand das
+                    // Adminrecht — sonst gäbe es einen Zustand ohne jeden
+                    // Administrator, und aus dem führt kein Weg zurück.
+                    IsOwner = true,
                 };
                 db.Users.Add(administrator);
                 await db.SaveChangesAsync();

server/src/Flaro.Core/Users/User.cs

@@ -19,6 +19,24 @@ public sealed class User
 
     public bool IsAdministrator { get; set; }
 
+    /// <summary>Dem Besitzer kann niemand das Adminrecht nehmen.</summary>
+    ///
+    /// <remarks>
+    /// <para>
+    /// <b>Damit sich ein Server nicht selbst aussperren kann.</b> Sobald
+    /// Administratoren einander das Recht entziehen können, gibt es einen
+    /// Zustand ohne jeden Administrator — und aus dem führt kein Weg zurück
+    /// ausser dem an der Datenbank. Ein Konto, das ausgenommen ist, schliesst
+    /// diesen Zustand aus.
+    /// </para>
+    /// <para>
+    /// <b>Es ist das erste Konto</b>, also das, mit dem der Server
+    /// eingerichtet wurde. Übertragen lässt es sich — an einen anderen
+    /// Administrator, und nur vom Besitzer selbst.
+    /// </para>
+    /// </remarks>
+    public bool IsOwner { get; set; }
+
     /// <summary>Die bevorzugte Sprache — <c>null</c> heisst: die des Servers.</summary>
     ///
     /// <remarks>

server/src/Flaro.Data/Migrations/20261007162057_Besitzer.cs

@@ -0,0 +1,43 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Flaro.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class Besitzer : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsOwner",
+                table: "Users",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: false);
+
+            // **Der Älteste erbt.** Auf einem Server, den es schon gibt, ist
+            // der Besitzer das Konto, mit dem eingerichtet wurde — und das
+            // ist das mit der kleinsten Kennung, weil die zeitlich geordnet
+            // vergeben werden (`Guid.CreateVersion7`).
+            //
+            // Ohne diese Zeilen hätte ein bestehender Server gar keinen
+            // Besitzer, und das Adminrecht liesse sich bis zum letzten
+            // Administrator abräumen.
+            migrationBuilder.Sql(
+                """
+                UPDATE Users SET IsOwner = 1
+                WHERE Id = (SELECT Id FROM Users ORDER BY Id LIMIT 1);
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsOwner",
+                table: "Users");
+        }
+    }
+}

server/src/Flaro.Data/Migrations/FlaroContextModelSnapshot.cs

@@ -929,6 +929,9 @@ namespace Flaro.Data.Migrations
                     b.Property<bool>("IsAdministrator")
                         .HasColumnType("INTEGER");
 
+                    b.Property<bool>("IsOwner")
+                        .HasColumnType("INTEGER");
+
                     b.Property<string>("Language")
                         .HasMaxLength(16)
                         .HasColumnType("TEXT");

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

@@ -0,0 +1,189 @@
+using System.Net;
+using System.Net.Http.Json;
+using Flaro.Api.Endpoints;
+
+namespace Flaro.Api.Tests;
+
+/// <summary>Adminrecht geben und nehmen — und der eine, dem es niemand nimmt.</summary>
+///
+/// <remarks>
+/// <b>Worum es hier wirklich geht: ein Server ohne jeden Administrator.</b>
+/// Sobald Administratoren einander das Recht entziehen können, gibt es diesen
+/// Zustand — und aus ihm führt kein Weg zurück ausser dem an der Datenbank.
+/// Jeder Test hier prüft eine der Türen, durch die man hineingeraten könnte.
+/// </remarks>
+public class BesitzerTests
+{
+    [Test]
+    public async Task Wer_einrichtet_ist_Besitzer()
+    {
+        using var server = new FlaroServer();
+        var admin = await server.SetUpAndSignIn();
+        var alsAdmin = server.AlsAngemeldeter(admin.Token);
+
+        var ich = await alsAdmin.GetFromJsonAsync<AuthenticatedUser>("/api/v1/users/me");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(admin.User.IsOwner, Is.True, "Schon die Anmeldung muss es sagen.");
+            Assert.That(ich!.IsOwner, Is.True);
+        });
+    }
+
+    [Test]
+    public async Task Aus_einem_Benutzer_wird_ein_Administrator_und_zurueck()
+    {
+        using var server = new FlaroServer();
+        var admin = await server.SetUpAndSignIn();
+        var alsAdmin = server.AlsAngemeldeter(admin.Token);
+        var gast = await server.NeuerBenutzer(alsAdmin, "gast", "gastpasswortlang");
+
+        var vorher = await gast.GetAsync("/api/v1/users");
+
+        (await alsAdmin.PutAsJsonAsync($"/api/v1/users/{await KennungVon(alsAdmin, "gast")}/administrator",
+            new RechtRequest(true))).EnsureSuccessStatusCode();
+
+        // **Die Rolle wird je Anfrage frisch gelesen**, nicht aus dem Token —
+        // der Gast braucht sich also nicht neu anzumelden.
+        var danach = await gast.GetAsync("/api/v1/users");
+
+        (await alsAdmin.PutAsJsonAsync($"/api/v1/users/{await KennungVon(alsAdmin, "gast")}/administrator",
+            new RechtRequest(false))).EnsureSuccessStatusCode();
+        var wiederZu = await gast.GetAsync("/api/v1/users");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(vorher.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden));
+            Assert.That(danach.StatusCode, Is.EqualTo(HttpStatusCode.OK),
+                "Das Recht muss sofort gelten, ohne neue Anmeldung.");
+            Assert.That(wiederZu.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden));
+        });
+    }
+
+    [Test]
+    public async Task Dem_Besitzer_nimmt_niemand_das_Adminrecht()
+    {
+        using var server = new FlaroServer();
+        var admin = await server.SetUpAndSignIn();
+        var alsAdmin = server.AlsAngemeldeter(admin.Token);
+
+        var zweiter = await server.NeuerBenutzer(alsAdmin, "zweiter", "zweiterpasswortlang");
+        var zweiteKennung = await KennungVon(alsAdmin, "zweiter");
+        await alsAdmin.PutAsJsonAsync($"/api/v1/users/{zweiteKennung}/administrator",
+            new RechtRequest(true));
+
+        // Auch ein zweiter Administrator kommt an den Besitzer nicht heran.
+        var versuch = await zweiter.PutAsJsonAsync(
+            $"/api/v1/users/{admin.User.Id}/administrator", new RechtRequest(false));
+        var geloescht = await zweiter.DeleteAsync($"/api/v1/users/{admin.User.Id}");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(versuch.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+            Assert.That(geloescht.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+        });
+        Assert.That(await versuch.Content.ReadAsStringAsync(), Does.Contain("Besitzer"));
+    }
+
+    [Test]
+    public async Task Das_eigene_Adminrecht_nimmt_man_sich_nicht_selbst()
+    {
+        using var server = new FlaroServer();
+        var admin = await server.SetUpAndSignIn();
+        var alsAdmin = server.AlsAngemeldeter(admin.Token);
+
+        var zweiter = await server.NeuerBenutzer(alsAdmin, "zweiter", "zweiterpasswortlang");
+        var zweiteKennung = await KennungVon(alsAdmin, "zweiter");
+        await alsAdmin.PutAsJsonAsync($"/api/v1/users/{zweiteKennung}/administrator",
+            new RechtRequest(true));
+
+        var selbst = await zweiter.PutAsJsonAsync(
+            $"/api/v1/users/{zweiteKennung}/administrator", new RechtRequest(false));
+        var selbstWeg = await zweiter.DeleteAsync($"/api/v1/users/{zweiteKennung}");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(selbst.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+            Assert.That(selbstWeg.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+        });
+    }
+
+    [Test]
+    public async Task Der_Besitz_geht_nur_vom_Besitzer_und_nur_an_einen_Administrator()
+    {
+        using var server = new FlaroServer();
+        var admin = await server.SetUpAndSignIn();
+        var alsAdmin = server.AlsAngemeldeter(admin.Token);
+        var gast = await server.NeuerBenutzer(alsAdmin, "gast", "gastpasswortlang");
+        var gastKennung = await KennungVon(alsAdmin, "gast");
+
+        // Noch kein Administrator — also noch kein Besitzer.
+        var zuFrueh = await alsAdmin.PostAsync($"/api/v1/users/{gastKennung}/owner", null);
+
+        await alsAdmin.PutAsJsonAsync($"/api/v1/users/{gastKennung}/administrator",
+            new RechtRequest(true));
+
+        // Der Beschenkte kann sich den Besitz nicht selbst nehmen.
+        var selbstGenommen = await gast.PostAsync($"/api/v1/users/{gastKennung}/owner", null);
+
+        var uebergeben = await alsAdmin.PostAsync($"/api/v1/users/{gastKennung}/owner", null);
+        var alle = await alsAdmin.GetFromJsonAsync<List<AuthenticatedUser>>("/api/v1/users");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(zuFrueh.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+            Assert.That(selbstGenommen.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+            Assert.That(uebergeben.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
+            Assert.That(alle!.Count(u => u.IsOwner), Is.EqualTo(1), "Genau einer, immer.");
+            Assert.That(alle!.Single(u => u.IsOwner).UserName, Is.EqualTo("gast"));
+        });
+    }
+
+    /// <summary>Ein gelöschtes Konto nimmt mit, was an ihm hing.</summary>
+    [Test]
+    public async Task Ein_geloeschtes_Konto_laesst_nichts_zurueck()
+    {
+        using var server = new FlaroServer();
+        var admin = await server.SetUpAndSignIn();
+        var alsAdmin = server.AlsAngemeldeter(admin.Token);
+        var gast = await server.NeuerBenutzer(alsAdmin, "gast", "gastpasswortlang");
+        var gastKennung = await KennungVon(alsAdmin, "gast");
+
+        // Etwas, das an ihm hängt.
+        await gast.PostAsJsonAsync($"/api/v1/items/{Guid.CreateVersion7()}/reports",
+            new MeldungRequest("bild", "Egal."));
+
+        (await alsAdmin.DeleteAsync($"/api/v1/users/{gastKennung}")).EnsureSuccessStatusCode();
+
+        var alle = await alsAdmin.GetFromJsonAsync<List<AuthenticatedUser>>("/api/v1/users");
+        // Das alte Token gilt nicht mehr: die Geräte hingen am Konto.
+        var mitAltemToken = await gast.GetAsync("/api/v1/users/me");
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(alle!.Select(u => u.UserName), Does.Not.Contain("gast"));
+            Assert.That(mitAltemToken.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized));
+        });
+    }
+
+    [Test]
+    public async Task Rechte_vergeben_darf_nur_die_Verwaltung()
+    {
+        using var server = new FlaroServer();
+        var admin = await server.SetUpAndSignIn();
+        var alsAdmin = server.AlsAngemeldeter(admin.Token);
+        var gast = await server.NeuerBenutzer(alsAdmin, "gast", "gastpasswortlang");
+        var gastKennung = await KennungVon(alsAdmin, "gast");
+
+        var versuch = await gast.PutAsJsonAsync(
+            $"/api/v1/users/{gastKennung}/administrator", new RechtRequest(true));
+
+        Assert.That(versuch.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden));
+    }
+
+    private static async Task<Guid> KennungVon(HttpClient alsAdmin, string name)
+    {
+        var alle = await alsAdmin.GetFromJsonAsync<List<AuthenticatedUser>>("/api/v1/users");
+        return alle!.Single(u => u.UserName == name).Id;
+    }
+}