Nutzer sperren in Supabase: ban_duration, Sessions und Moderation
Supabase kann Nutzer mit einem einzigen Admin-Aufruf sperren. Damit die Sperre auch dort greift, wo noch ein gültiges Access-Token unterwegs ist, braucht es zwei, drei Ergänzungen in Edge Functions und Row Level Security.
Dieser Ratgeber zeigt, wie du Nutzer in Supabase sperrst, warum die Sperre nicht überall sofort wirkt und wie du das schließt. Er funktioniert ohne Limenia. Was Limenia abnehmen kann, steht im letzten Abschnitt.
ban_duration in der Auth Admin API
Supabase Auth speichert für jeden Nutzer ein banned_until. Du setzt es über die Admin-API mit ban_duration, im JavaScript-Client mit auth.admin.updateUserById. Der Aufruf gehört in eine Edge Function oder ein anderes Backend, denn er braucht einen Secret Key.
import { createClient } from "npm:@supabase/supabase-js@2";
// Edge Functions bekommen alle Secret Keys des Projekts nach Namen, hier den Key "moderation"
const secretKeys = JSON.parse(Deno.env.get("SUPABASE_SECRET_KEYS")!);
const admin = createClient(Deno.env.get("SUPABASE_URL")!, secretKeys["moderation"], {
auth: { persistSession: false, autoRefreshToken: false },
});
async function setBan(userId: string, banDuration: string) {
const { error } = await admin.auth.admin.updateUserById(userId, { ban_duration: banDuration });
if (error) throw error;
}
// dauerhaft: rund 100 Jahre
await setBan(userId, "876000h");
// auf Zeit, bis zu einem Zeitpunkt
const seconds = Math.ceil((until.getTime() - Date.now()) / 1000);
await setBan(userId, `${seconds}s`);
// aufheben
await setBan(userId, "none");
Die drei Fälle:
| Fall | ban_duration |
Was passiert |
|---|---|---|
| Dauerhafte Sperre | 876000h |
banned_until liegt rund 100 Jahre in der Zukunft |
| Sperre auf Zeit | Dauer wie 72h oder 259200s |
Die Sperre endet von selbst, du musst nichts planen |
| Sperre aufheben | none |
banned_until wird gelöscht |
Die Dauer folgt dem Format von Go: Zahlen mit den Einheiten ns, us (oder µs), ms, s, m und h, auch kombiniert wie 2h45m. Eine Einheit für Tage gibt es nicht.
Lösch gesperrte Nutzer nicht. Hat eine Beschwerde Erfolg, musst du die Sperre aufheben können, und das geht nur, solange das Konto existiert.
Warum der Ban nicht sofort alle Sessions beendet
Supabase prüft die Sperre an drei Stellen sofort: bei der Anmeldung, beim Token-Refresh und bei Aufrufen an Supabase Auth selbst, etwa getUser(). Der Refresh scheitert mit „Invalid Refresh Token: User Banned“, die Anmeldung mit dem Fehlercode user_banned.
Was nicht sofort stoppt, ist ein schon ausgestelltes Access-Token. Es ist ein signiertes JWT und gilt bis zu seinem Ablauf, im Standard eine Stunde. Bis dahin akzeptieren die Datenbank-API, Storage und Realtime es weiter, und Row Level Security sieht nur auth.uid(), nicht die Sperre. Eine Session per Nutzer-ID beenden kann Supabase nicht: auth.admin.signOut erwartet das JWT der Session, nicht die Nutzer-ID.
Für die meisten Apps ist eine Stunde Nachlauf vertretbar. Bei Belästigung im Chat oder Spam-Wellen eher nicht. Dann helfen die nächsten beiden Abschnitte.
getUser() statt getClaims() oder kürzere JWT-Laufzeit
In Edge Functions hast du zwei Wege, den Nutzer zum Token zu bestimmen:
getClaims()prüft das JWT bei asymmetrischen Signaturschlüsseln lokal gegen die JWKS deines Projekts. Das ist schnell, sieht aber keine Sperre, solange das Token gültig ist.getUser()fragt bei jedem Aufruf den Auth-Server. Für gesperrte Nutzer antwortet er mit einem Fehler.
Für Aktionen, die eine Sperre sofort stoppen soll (posten, Nachrichten schicken, melden), nimm getUser():
import { createClient } from "npm:@supabase/supabase-js@2";
const publishableKeys = JSON.parse(Deno.env.get("SUPABASE_PUBLISHABLE_KEYS")!);
const supabase = createClient(Deno.env.get("SUPABASE_URL")!, publishableKeys["default"]);
Deno.serve(async (req) => {
const token = req.headers.get("Authorization")?.replace(/^Bearer\s+/i, "");
if (!token) return new Response("Unauthorized", { status: 401 });
const { data, error } = await supabase.auth.getUser(token);
if (error || !data.user) return new Response("Forbidden", { status: 403 }); // auch bei Sperre
// ... Aktion für data.user.id
return new Response(null, { status: 204 });
});
Für direkte Datenbank-Zugriffe aus der App ergänzt du eine restriktive Policy. Sie wird mit allen anderen Policies per UND verknüpft. Die Funktion liegt in einem Schema, das die Datenbank-API nicht ausliefert, weil sie als security definer läuft:
create schema if not exists private;
create or replace function private.is_banned()
returns boolean
language sql
stable
security definer
set search_path = ''
as $$
select coalesce(
(select u.banned_until > now() from auth.users u where u.id = auth.uid()),
false
);
$$;
grant usage on schema private to authenticated;
revoke execute on function private.is_banned() from public, anon;
grant execute on function private.is_banned() to authenticated;
create policy "banned users cannot post"
on public.posts
as restrictive
for insert
to authenticated
with check (not (select private.is_banned()));
Das (select …) um den Funktionsaufruf lässt Postgres das Ergebnis einmal pro Abfrage berechnen statt pro Zeile. Dieselbe Policy kannst du für update, für Nachrichten und für Storage-Buckets anlegen.
Die dritte Möglichkeit: die Laufzeit der Access-Tokens verkürzen, in den Auth-Einstellungen unter Sessions. Supabase empfiehlt mindestens fünf Minuten. Kürzere Tokens bedeuten mehr Refreshs und schließen die Lücke nur teilweise.
Eigener Secret Key statt service_role
Supabase hat neue API-Keys eingeführt: Publishable Keys (sb_publishable_…) für die App und Secret Keys (sb_secret_…) für das Backend. Die alten Keys anon und service_role laufen laut Supabase-Doku bis Ende 2026 aus.
Für Sperren aus einer Edge Function heißt das:
- Leg im Dashboard unter API Keys einen eigenen Secret Key an, etwa mit dem Namen
moderation. - In gehosteten Edge Functions steht er automatisch in
SUPABASE_SECRET_KEYS, einem JSON-Objekt nach Namen. Du liest ihn mitJSON.parse(Deno.env.get("SUPABASE_SECRET_KEYS")!)["moderation"], wie im Code oben. - Nutze ihn nur in den Functions, die die Admin-API brauchen.
Ein eigener Key lässt sich einzeln löschen, wenn er kompromittiert ist, ohne andere Dienste zu treffen. Wichtig bleibt: Secret Keys umgehen jede RLS-Policy. Sie gehören nie in die Flutter-App, nie in Remote Config und nie in Git. Supabase lehnt Secret Keys im Browser ab, eine Mobile-App schützt das nicht.
Inhalte moderieren mit Edge Functions und Webhooks
Sperren ist das Ende des Ablaufs. Am Anfang steht die Meldung. Mit Supabase geht das ohne eigene Function, wenn RLS festlegt, wer meldet, und ein Trigger den Schnappschuss nimmt:
create table public.reports (
id uuid primary key default gen_random_uuid(),
reporter_id uuid not null default auth.uid() references auth.users (id),
post_id uuid not null references public.posts (id),
reason_category text not null check (reason_category ~ '^[a-z0-9_]{2,40}$'),
reason_text text check (char_length(reason_text) <= 2000),
author_id uuid,
snapshot_text text,
status text not null default 'open',
created_at timestamptz not null default now(),
unique (post_id, reporter_id)
);
alter table public.reports enable row level security;
create policy "report as yourself"
on public.reports for insert to authenticated
with check (reporter_id = (select auth.uid()) and status = 'open');
-- Schnappschuss aus der Datenbank, nicht aus der App
create or replace function private.fill_report_snapshot()
returns trigger
language plpgsql
security definer
set search_path = ''
as $$
begin
select p.author_id, p.content into new.author_id, new.snapshot_text
from public.posts p where p.id = new.post_id;
return new;
end;
$$;
create trigger reports_snapshot before insert on public.reports
for each row execute function private.fill_report_snapshot();
Ohne Select-Policy sieht niemand fremde Meldungen. Die unique-Bedingung verhindert doppelte Meldungen derselben Person.
Für den nächsten Schritt legst du einen Database Webhook auf insert in reports an. Er ruft asynchron eine Edge Function auf, die das Moderationsteam benachrichtigt oder die Meldung an ein Moderationswerkzeug weiterleitet. Gib dem Webhook einen geheimen Header mit und prüf ihn in der Function, denn die Function-URL ist öffentlich.
Nach der Entscheidung setzt eine Function die Maßnahme um: Beitrag ausblenden (status = 'removed' statt löschen), Nutzer sperren und die Begründung schicken. Nach Art. 17 DSA braucht jede Sperre und jede Entfernung eine klare und spezifische Begründung, Details im Ratgeber zur Begründung nach Art. 17 DSA. Ein gesperrter Nutzer kann sich nicht mehr anmelden. Schick die Begründung per E-Mail und zeig sie, wenn die Anmeldung mit user_banned scheitert. Wie Beschwerden gegen Sperren laufen, steht im Ratgeber zum internen Beschwerdemanagement.
Mit Limenia: Supabase-Connector
Limenia übernimmt den Teil zwischen Meldung und Maßnahme: Meldungen bündeln, im Dashboard entscheiden, Begründung nach Art. 17 erzeugen, Meldende informieren, Beschwerden annehmen. Deine Edge Function leitet Meldungen an POST /v1/reports weiter, der API-Key liegt als Function-Secret, nie in der App.
Der Supabase-Connector (Pro und Premium) setzt Sperren direkt in Supabase Auth um:
| Entscheidung in Limenia | In Supabase Auth |
|---|---|
| Dauerhafte Sperre | ban_duration: 876000h |
| Sperre auf Zeit | die verbleibenden Sekunden bis zum Ende, Supabase hebt sie selbst auf |
| Konto wiederherstellen, Ende einer Sperre | ban_duration: none |
| Inhalt entfernen, verwarnen | nichts, das läuft über den Webhook |
Du legst dafür einen eigenen Secret Key nur für Limenia an. Alte service_role-Keys nimmt Limenia nicht an. An Supabase gehen nur Nutzer-UUID und Sperrdauer, Nutzer löscht Limenia nie. Voraussetzung ist, dass dein Backend die UUID aus auth.users.id als Nutzer-ID schickt.
Der Connector ändert keine Tabellen. Inhalte ausblenden und die Begründung anzeigen erledigt dein Webhook-Empfänger, und getUser() und die RLS-Policy von oben bleiben sinnvoll. Ein Beispiel mit Edge Functions liegt im Beispiel-Repo auf GitHub, Schritt für Schritt steht alles im Integrationsleitfaden unter 2.5. Für Flutter-Apps gibt es das Paket limenia auf pub.dev mit fertigen Widgets für Meldedialog, Beschwerde und Begründung. Mehr zum Connector auf Moderation für Supabase-Apps, zur App-Seite auf Moderation für Flutter-Apps.
Supabase ist eine Marke von Supabase, Inc. Flutter ist eine Marke von Google LLC.
Quellen
- Supabase JavaScript-Referenz: auth.admin.updateUserByIdsupabase.com
- Supabase JavaScript-Referenz: auth.getClaimssupabase.com
- Supabase: User sessionssupabase.com
- Supabase: Understanding API keyssupabase.com
- Supabase: Row Level Securitysupabase.com
- Supabase: Edge Function secretssupabase.com
- Supabase: Database Webhookssupabase.com
- Verordnung (EU) 2022/2065 (Digital Services Act), Art. 17 und 20, EUR-Lexeur-lex.europa.eu
- Limenia: Integrationsleitfaden (Abschnitt 2.5 Flutter + Supabase, 7.2 Supabase-Connector)limenia.eu
- Limenia: Beispiel-Backends auf GitHub (Apache 2.0)github.com