Melden und Sperren in Flutter-Apps mit Firebase: Architektur, Code und DSA
Ein Melde-Button ist schnell gebaut. Damit Meldungen vertrauenswürdig sind und Sperren wirklich greifen, braucht es ein paar Entscheidungen im Backend. Hier ist eine Architektur, die mit Firebase funktioniert, mit Code für Flutter, Cloud Functions und Firestore-Regeln.
Dieser Ratgeber zeigt, wie du in einer Flutter-App mit Firebase Inhalte melden, Nutzer blockieren und Konten sperren lässt. Er funktioniert ohne Limenia. Wo ein Moderationswerkzeug Arbeit abnimmt, steht das am Ende.
Die Architektur: App → Cloud Function → Moderation → zurück
Vier Bausteine, jeder mit einer klaren Aufgabe:
- Flutter-App: zeigt den Melde-Button und das Blockieren an. Sie schickt nur IDs und den Meldegrund.
- Cloud Function (Callable): nimmt die Meldung an, liest die meldende Person aus dem ID-Token, holt den gemeldeten Inhalt selbst aus Firestore und speichert einen Schnappschuss.
- Moderation: jemand prüft die Meldung und entscheidet. Das kann eine eigene Admin-Oberfläche sein oder ein Tool, das per API angebunden ist.
- Zurück in Firebase: eine Function setzt die Entscheidung um, entfernt den Inhalt, sperrt das Konto und schickt die Begründung.
Flutter-App ──httpsCallable──▶ Cloud Function ──▶ Moderation
│ Entscheidung
Firestore / Firebase Auth ◀── Cloud Function ◀────────┘
Warum nicht direkt aus der App in eine Firestore-Collection reports schreiben? Weil dann die App bestimmt, was gemeldet wurde und von wem. Ein manipulierter Client kann fremde Texte als Schnappschuss einreichen. Eine Function liest den Inhalt aus deiner Datenbank und ist damit die Quelle der Wahrheit.
Melde-Button in Flutter
Die App fragt nur den Grund ab und ruft die Function auf. Für Meldungen über rechtswidrige Inhalte verlangt Art. 16 Abs. 2 DSA unter anderem eine hinreichend begründete Erklärung. Biete deshalb ein Freitextfeld an, zumindest für den Grund „rechtswidrig“.
import 'package:cloud_functions/cloud_functions.dart';
import 'package:flutter/material.dart';
const reasons = {
'spam': 'Spam',
'harassment_hate': 'Belästigung oder Hass',
'sexual_content': 'Sexuelle Inhalte',
'other': 'Etwas anderes',
};
Future<void> showReportSheet(BuildContext context, String commentId) async {
final reason = await showModalBottomSheet<String>(
context: context,
builder: (context) => SafeArea(
child: ListView(
shrinkWrap: true,
children: [
for (final entry in reasons.entries)
ListTile(
title: Text(entry.value),
onTap: () => Navigator.pop(context, entry.key),
),
],
),
),
);
if (reason == null) return;
final callable = FirebaseFunctions.instanceFor(region: 'europe-west3')
.httpsCallable('reportComment');
try {
await callable.call(<String, dynamic>{'commentId': commentId, 'reasonCategory': reason});
if (context.mounted) {
ScaffoldMessenger.of(context).showSnackBar(
const SnackBar(content: Text('Danke. Wir prüfen die Meldung.')),
);
}
} on FirebaseFunctionsException catch (e) {
debugPrint('report failed: ${e.code}'); // nur den Code loggen, keine Inhalte
}
}
Die Function liest die meldende Person aus request.auth, nie aus request.data:
import { initializeApp } from "firebase-admin/app";
import { getAuth } from "firebase-admin/auth";
import { FieldValue, getFirestore } from "firebase-admin/firestore";
import { HttpsError, onCall } from "firebase-functions/v2/https";
initializeApp();
export const reportComment = onCall({ region: "europe-west3" }, async (request) => {
if (!request.auth) throw new HttpsError("unauthenticated", "Sign in first.");
const { commentId, reasonCategory, reasonText } = request.data ?? {};
if (typeof commentId !== "string" || typeof reasonCategory !== "string") {
throw new HttpsError("invalid-argument", "commentId and reasonCategory are required.");
}
const db = getFirestore();
const comment = await db.collection("comments").doc(commentId).get();
if (!comment.exists) throw new HttpsError("not-found", "Comment not found.");
const reporterUid = request.auth.uid; // aus dem ID-Token, nie aus request.data
await db.collection("reports").doc(`${commentId}_${reporterUid}`).set({
reporterUid,
commentId,
authorUid: comment.get("authorUid"),
text: comment.get("text"), // Schnappschuss: der Kommentar kann später geändert oder gelöscht werden
reasonCategory,
reasonText: typeof reasonText === "string" ? reasonText.slice(0, 2000) : null,
status: "open",
createdAt: FieldValue.serverTimestamp(),
});
return { ok: true };
});
Die Dokument-ID aus Kommentar und meldender Person macht wiederholte Aufrufe harmlos: Wer zweimal tippt, erzeugt eine Meldung, nicht zwei. Die Collection reports sperrst du in den Firestore-Regeln für Clients komplett, nur das Admin SDK schreibt dort.
Blockieren zwischen Nutzern
Blockieren ist etwas anderes als Sperren. Eine Person blendet eine andere für sich aus und verhindert, dass sie ihr schreibt. Das Konto bleibt aktiv, und du als Anbieter triffst keine Entscheidung.
Die Stores verlangen das in unterschiedlicher Form. Google Play schreibt für Funktionen mit direkter Interaktion zwischen einzelnen Nutzern (etwa Direktnachrichten, Markierungen, Erwähnungen) eine In-App-Funktion zum Blockieren vor. Apple nennt in Guideline 1.2 „the ability to block abusive users from the service“. Mehr dazu im Ratgeber zur App Store Guideline 1.2.
Eine Blockierliste pro Person reicht: users/{uid}/blocked/{otherUid}. Die App filtert Feeds und Kommentare damit auf dem Gerät. Durchsetzen musst du die Blockierung aber in den Regeln, sonst kann ein angepasster Client trotzdem Nachrichten schicken:
rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
function signedIn() { return request.auth != null; }
function notBanned() {
return !exists(/databases/$(database)/documents/bans/$(request.auth.uid));
}
function members(chatId) {
return get(/databases/$(database)/documents/chats/$(chatId)).data.members;
}
function hasBlocked(owner, other) {
return exists(/databases/$(database)/documents/users/$(owner)/blocked/$(other));
}
match /users/{uid}/blocked/{otherUid} {
allow read, write: if signedIn() && request.auth.uid == uid;
}
match /chats/{chatId}/messages/{messageId} {
allow create: if signedIn() && notBanned()
&& request.resource.data.senderUid == request.auth.uid
&& request.auth.uid in members(chatId)
&& request.resource.data.recipientUid in members(chatId)
&& !hasBlocked(request.resource.data.recipientUid, request.auth.uid);
}
}
}
Jeder get()- und exists()-Aufruf in den Regeln zählt als Lesevorgang. Halte die Prüfungen deshalb bei den Schreibregeln und lies nicht bei jedem Listeneintrag nach.
Konto sperren: updateUser({disabled: true}) und Refresh-Tokens widerrufen
Eine Sperre setzt du mit dem Admin SDK, also in einer Function oder einem anderen Backend. Zwei Aufrufe gehören zusammen:
import { getAuth } from "firebase-admin/auth";
import { FieldValue, getFirestore, Timestamp } from "firebase-admin/firestore";
export async function suspendUser(uid, until /* Date oder null für dauerhaft */, decisionId) {
await getAuth().updateUser(uid, { disabled: true }); // keine neue Anmeldung, kein Token-Refresh
await getAuth().revokeRefreshTokens(uid); // bestehende Sitzungen enden beim nächsten Refresh
await getFirestore().collection("bans").doc(uid).set({
until: until ? Timestamp.fromDate(until) : null,
decisionId,
createdAt: FieldValue.serverTimestamp(),
});
}
Firebase Authentication kennt keine Sperre mit Ablaufdatum. Für eine Sperre auf Zeit hebst du sie selbst wieder auf, zum Beispiel stündlich:
import { onSchedule } from "firebase-functions/v2/scheduler";
export const liftExpiredSuspensions = onSchedule(
{ schedule: "every 60 minutes", region: "europe-west3" },
async () => {
const due = await getFirestore().collection("bans").where("until", "<=", Timestamp.now()).get();
for (const doc of due.docs) {
await getAuth().updateUser(doc.id, { disabled: false });
await doc.ref.delete();
}
},
);
Dauerhafte Sperren haben until: null und fallen aus der Abfrage heraus. Lösch gesperrte Konten nicht: Hat eine Beschwerde Erfolg, musst du die Sperre aufheben können.
Und Custom Claims?
Ein Claim wie banned: true wirkt erst, wenn der Client ein neues ID-Token bekommt, also nach erneuter Anmeldung oder beim nächsten Refresh. Ein deaktiviertes Konto bekommt aber gar kein neues Token mehr. Laut Firebase sind Claims außerdem nur für Zugriffssteuerung gedacht und auf 1000 Bytes begrenzt. Für Rollen wie „Moderator“ sind sie gut, für Sperren ist disabled plus eine Sperrliste die bessere Wahl.
Warum gesperrte Nutzer bis zu einer Stunde weiterarbeiten können
Firebase-ID-Tokens gelten eine Stunde. Deaktivieren und Widerrufen verhindern nur, dass ein neues Token ausgestellt wird. Ein schon ausgestelltes Token prüfen Firestore- und Storage-Regeln weiter als gültig, bis es abläuft. Auch onCall prüft das Token ohne Widerrufsprüfung.
Wo die Sperre sofort greifen muss, hast du drei Hebel:
-
Eigene HTTP-Endpunkte:
getAuth().verifyIdToken(token, true). MitcheckRevokedfragt das Admin SDK zusätzlich den Auth-Server ab und wirftauth/user-disabledoderauth/id-token-revoked. -
Callable Functions: das rohe Token liegt in
request.auth.rawToken. Prüf es bei sensiblen Aktionen nach:try { await getAuth().verifyIdToken(request.auth.rawToken, true); } catch { throw new HttpsError("permission-denied", "Account suspended."); } -
Firestore-Regeln: die Sperrliste
bans/{uid}aus dem Abschnitt oben, geprüft mitnotBanned()in jeder Schreibregel für Nutzerinhalte.
Firebase beschreibt für die Realtime Database ein ähnliches Muster mit einem gespeicherten Widerrufszeitpunkt, der mit auth_time im Token verglichen wird. Die Sperrliste ist einfacher und reicht für Moderation.
Inhalte entfernen und die Begründung anzeigen
Entfernen heißt in der Regel: Inhalt ausblenden statt löschen, zum Beispiel mit status: "removed" und einer Leseregel, die nur sichtbare Inhalte zeigt. So kannst du nach einer erfolgreichen Beschwerde wiederherstellen. Leg eine Frist fest, nach der entfernte Inhalte endgültig gelöscht werden.
Jede Sperre und jede Entfernung braucht nach Art. 17 DSA eine klare und spezifische Begründung, spätestens wenn die Maßnahme wirkt. Sie nennt Maßnahme und Dauer, die Tatsachen, ob automatisierte Mittel beteiligt waren, die verletzte Regel oder Rechtsnorm und die Rechtsbehelfe. Was genau hineingehört, steht im Ratgeber zur Begründung nach Art. 17 DSA.
Bei einer Kontosperre gibt es eine Hürde: Die Person kann sich nicht mehr anmelden. Schick die Begründung deshalb per E-Mail und zeig sie zusätzlich beim Anmeldeversuch. FlutterFire meldet dann eine FirebaseAuthException mit dem Code user-disabled. Fang ihn ab und zeig einen Bildschirm mit dem Hinweis auf die Sperre und den Weg zur Beschwerde, statt einer allgemeinen Fehlermeldung.
Meldende nicht vergessen
Art. 16 Abs. 5 DSA verlangt, dass du der meldenden Person deine Entscheidung mitteilst. Speichere deshalb zu jeder Meldung, wer sie geschickt hat, und benachrichtige sie, wenn der Fall entschieden ist.
Mit Limenia: Webhook oder Firebase-Connector
Den Teil „Moderation“ aus der Architektur kann Limenia übernehmen: Meldungen bündeln, im Dashboard entscheiden, die Begründung nach Art. 17 erzeugen, Meldende informieren und Beschwerden annehmen. Die Function reportComment leitet dann an POST /v1/reports weiter, statt selbst zu speichern. Der API-Key liegt als Secret in deinen Functions (firebase functions:secrets:set LIMENIA_API_KEY), nie in der App.
Die Entscheidung kommt auf zwei Wegen zurück:
- Webhook
decision.created: eineonRequest-Function prüft die Signatur überreq.rawBodyund setzt die Aktion um, also Inhalt ausblenden, Sperrliste pflegen und die fertige Begründung an die betroffene Person schicken. - Firebase-Connector (Pro und Premium): Limenia deaktiviert das Konto in Firebase Authentication selbst und widerruft die Refresh-Tokens, bei Aufhebung oder Ende einer Sperre aktiviert es das Konto wieder. Dafür bekommt das Service-Konto von Limenia eine Custom Role mit drei Berechtigungen, Limenia speichert keine Schlüssel deines Projekts. Voraussetzung ist, dass dein Backend die Firebase-UID als Nutzer-ID schickt.
Der Connector ändert weder Firestore noch Storage noch Custom Claims. Den Webhook brauchst du also trotzdem, und die Prüfung mit verifyIdToken(token, true) bleibt sinnvoll. Ein lauffähiges Beispiel mit Cloud Functions liegt im Beispiel-Repo auf GitHub, Schritt für Schritt steht alles im Integrationsleitfaden unter 2.4. Für die App gibt es das Paket limenia auf pub.dev mit fertigem Meldedialog, Beschwerdeformular, Begründung und Sperrhinweis unter package:limenia/ui.dart; der Melde-Button von oben bleibt genauso möglich. Mehr zum Connector auf Moderation für Firebase-Apps und zur App-Seite auf Moderation für Flutter-Apps.
Firebase und Flutter sind Marken von Google LLC. Apple und App Store sind Marken von Apple Inc. Google Play ist eine Marke von Google LLC.
Quellen
- Firebase: Manage User Sessions (revokeRefreshTokens, checkRevoked)firebase.google.com
- Firebase: Manage Users (Admin SDK)firebase.google.com
- Firebase: Control Access with Custom Claimsfirebase.google.com
- Firebase: Call functions from your app (Callable Functions)firebase.google.com
- Firebase: Schedule functionsfirebase.google.com
- Firebase: Writing conditions for Cloud Firestore Security Rulesfirebase.google.com
- Verordnung (EU) 2022/2065 (Digital Services Act), Art. 16 und 17, EUR-Lexeur-lex.europa.eu
- Apple App Review Guidelines, 1.2 User-Generated Contentdeveloper.apple.com
- Google Play Console-Hilfe: Von Nutzern erstellte Inhaltesupport.google.com
- Limenia: Integrationsleitfaden (Abschnitt 2.4 Flutter + Firebase)limenia.eu
- Limenia: Beispiel-Backends auf GitHub (Apache 2.0)github.com