Grundlegende Sicherheitsregeln

Firebase Security Rules können Sie den Zugriff auf Ihre gespeicherten Daten steuern. Mit der flexiblen Regelsyntax können Sie Regeln für beliebige Bereiche erstellen – von sämtlichen Schreibvorgängen über die gesamte Datenbank bis hin zu Vorgängen in einem bestimmten Dokument.

In diesem Leitfaden werden einige der grundlegenden Anwendungsfälle beschrieben, die Sie bei der Einrichtung Ihrer App und beim Schutz Ihrer Daten implementieren sollten. Bevor Sie mit dem Schreiben von Regeln beginnen, sollten Sie sich jedoch mit der Sprache, in der sie geschrieben werden, und ihrem Verhalten vertraut machen.

So greifen Sie auf Ihre Regeln zu und aktualisieren sieFirebase Security Rules.

Help me use Firebase in my app.
1. Make sure that **Firebase agent skills** are installed and updated. For Claude Code, Codex, or Cursor agents, help me install the Firebase plugin. For other agents, run `npx skills add firebase/agent-skills`. Always try to use **Firebase agent skills** for Firebase-related tasks.
2. Help me write, validate, and deploy Firebase Security Rules to protect my app's data.

Standardregeln: Sperrmodus

Wenn Sie in der Firebase-Konsole eine Datenbank- oder Speicherinstanz erstellen, wählen Sie aus, ob Firebase Security Rules den Zugriff auf Ihre Daten einschränken soll (Sperrmodus) oder ob jeder darauf zugreifen darf (Testmodus). In Cloud Firestore und Realtime Database wird der Zugriff für alle Nutzer durch die Standardregeln für den Sperrmodus verweigert. In Cloud Storage können nur authentifizierte Nutzer auf die Speichergruppen zugreifen.

service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if false;
    }
  }
}

{
  "rules": {
    ".read": false,
    ".write": false
  }
}

service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read, write: if false;
    }
  }
}

Regeln für die Entwicklungsumgebung

Während Sie an Ihrer App arbeiten, benötigen Sie möglicherweise einen relativ offenen oder uneingeschränkten Zugriff auf Ihre Daten. Aktualisieren Sie Security Rules, bevor Sie Ihre App in der Produktion bereitstellen. Denken Sie auch daran, dass Ihre App öffentlich zugänglich ist, wenn Sie sie bereitstellen, auch wenn Sie sie noch nicht gestartet haben.

Denken Sie daran, dass Firebase Clients direkten Zugriff auf Ihre Daten ermöglicht und Firebase Security Rules die einzige Schutzmaßnahme ist, die den Zugriff für böswillige Nutzer blockiert. Die separate Definition von Regeln und Produktlogik hat eine Reihe von Vorteilen: Clients sind nicht für die Durchsetzung der Sicherheit verantwortlich, fehlerhafte Implementierungen gefährden Ihre Daten nicht und vor allem sind Sie nicht auf einen Vermittlungsserver angewiesen, um Daten vor der Außenwelt zu schützen.

Alle authentifizierten Nutzer

Wir empfehlen zwar nicht, Ihre Daten für alle angemeldeten Nutzer zugänglich zu machen, aber es kann während der Entwicklung Ihrer App nützlich sein, den Zugriff auf alle authentifizierten Nutzer festzulegen.

service cloud.firestore {
  match /databases/{database}/documents {
    match /some_collection/{document} {
      allow read, write: if request.auth != null;
    }
  }
}

{
  "rules": {
    "some_path": {
      ".read": "auth.uid !== null",
      ".write": "auth.uid !== null"
    }
  }
}

service firebase.storage {
  match /b/{bucket}/o {
    match /some_folder/{fileName} {
      allow read, write: if request.auth != null;
    }
  }
}

Produktionsreife Regeln

Wenn Sie die Bereitstellung Ihrer App vorbereiten, müssen Sie dafür sorgen, dass Ihre Daten geschützt sind und Ihre Nutzer ordnungsgemäß Zugriff erhalten. Verwenden Sie Authentication, um den nutzerbasierten Zugriff einzurichten, und lesen Sie direkt aus Ihrer Datenbank, um den datenbasierten Zugriff einzurichten.

Berücksichtigen Sie beim Strukturieren Ihrer Daten, dass die Art und Weise, wie Sie Ihre Regeln einrichten, sich darauf auswirkt, wie Sie den Zugriff auf Daten an verschiedenen Pfaden einschränken.

Zugriff nur für Rechteinhaber

Diese Regeln beschränken den Zugriff auf den authentifizierten Inhaber der Inhalte. Die Daten können nur von einem Nutzer gelesen und geschrieben werden und der Datenpfad enthält die ID des Nutzers.

Wann diese Regel funktioniert:Diese Regel eignet sich gut, wenn Daten nach Nutzer segmentiert sind, d. h., wenn nur der Nutzer, der die Daten erstellt hat, auf sie zugreifen muss.

Wenn diese Regel nicht funktioniert:Dieses Regelset funktioniert nicht, wenn mehrere Nutzer dieselben Daten schreiben oder lesen müssen. Nutzer überschreiben dann Daten oder können nicht auf Daten zugreifen, die sie erstellt haben.

So richten Sie diese Regel ein:Erstellen Sie eine Regel, die bestätigt, dass der Nutzer, der Zugriff zum Lesen oder Schreiben von Daten anfordert, der Nutzer ist, dem diese Daten gehören.

service cloud.firestore {
  match /databases/{database}/documents {
    // Allow only authenticated content owners access
    match /some_collection/{userId}/{document} {
      allow read, write: if request.auth != null && request.auth.uid == userId
    }
  }
}

{
  "rules": {
    "some_path": {
      "$uid": {
        // Allow only authenticated content owners access to their data
        ".read": "auth !== null && auth.uid === $uid",
        ".write": "auth !== null && auth.uid === $uid"
      }
    }
  }
}

// Grants a user access to a node matching their user ID
service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/file.txt"
    match /user/{userId}/{fileName} {
      allow read, write: if request.auth != null && request.auth.uid == userId;
    }
  }
}

Gemischter öffentlicher und privater Zugriff

Mit dieser Regel kann jeder ein Dataset lesen, aber nur der authentifizierte Rechteinhaber darf Daten an einem bestimmten Pfad erstellen oder ändern.

Wann diese Regel funktioniert:Diese Regel eignet sich gut für Apps, die öffentlich lesbare Elemente erfordern, aber den Bearbeitungszugriff auf die Eigentümer dieser Elemente beschränken müssen. Beispielsweise eine Chat-App oder ein Blog.

Wann funktioniert diese Regel nicht? Wie die Regel „Nur Rechteinhaber“ funktioniert dieses Regelset nicht, wenn mehrere Nutzer dieselben Daten bearbeiten müssen. Nutzer überschreiben letztendlich die Daten der anderen.

So richten Sie diese Regel ein:Erstellen Sie eine Regel, die Lesezugriff für alle Nutzer (oder alle authentifizierten Nutzer) ermöglicht und bestätigt, dass der Nutzer, der Daten schreibt, der Inhaber ist.

service cloud.firestore {
  match /databases/{database}/documents {
    // Allow public read access, but only content owners can write
    match /some_collection/{document} {
      // Allow public reads
      allow read: if true
      // Allow creation if the current user owns the new document
      allow create: if request.auth.uid == request.resource.data.author_uid;
      // Allow updates by the owner, and prevent change of ownership
      allow update: if request.auth.uid == request.resource.data.author_uid
                    && request.auth.uid == resource.data.author_uid;
      // Allow deletion if the current user owns the existing document
      allow delete: if request.auth.uid == resource.data.author_uid;
    }
  }
}

{
// Allow anyone to read data, but only authenticated content owners can
// make changes to their data

  "rules": {
    "some_path": {
      "$uid": {
        ".read": true,
        // or ".read": "auth.uid !== null" for only authenticated users
        ".write": "auth.uid === $uid"
      }
    }
  }
}

service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/file.txt"
    match /user/{userId}/{fileName} {
      allow read;
      allow write: if request.auth.uid == userId;
    }
  }
}

Attributbasierter und rollenbasierter Zugriff

Damit diese Regeln funktionieren, müssen Sie Attribute für Nutzer in Ihren Daten definieren und zuweisen. Firebase Security Rules die Anfrage anhand der Daten aus der Metadatenbank oder den Metadaten der Datei prüfen, um den Zugriff zu bestätigen oder zu verweigern.

Wann diese Regel funktioniert:Wenn Sie Nutzern eine Rolle zuweisen, können Sie mit dieser Regel den Zugriff basierend auf Rollen oder bestimmten Nutzergruppen einschränken. Wenn Sie beispielsweise Noten speichern, können Sie der Gruppe „Schüler/Studenten“ unterschiedliche Zugriffsebenen zuweisen (nur ihre Inhalte lesen), der Gruppe „Lehrkräfte“ (in ihrem Fach lesen und schreiben) und der Gruppe „Schulleiter“ (alle Inhalte lesen).

Wenn diese Regel nicht funktioniert:In Realtime Database und Cloud Storage kann in Ihren Regeln nicht die get()-Methode verwendet werden, die in Cloud Firestore-Regeln enthalten sein kann. Daher müssen Sie die Metadaten Ihrer Datenbank oder Datei so strukturieren, dass sie die Attribute widerspiegeln, die Sie in Ihren Regeln verwenden.

So richten Sie diese Regel ein:Fügen Sie in Cloud Firestore ein Feld in die Dokumente Ihrer Nutzer ein, das Sie lesen können. Strukturieren Sie dann Ihre Regel so, dass dieses Feld gelesen und der Zugriff bedingt gewährt wird. Erstellen Sie in Realtime Database einen Datenpfad, der die Nutzer Ihrer App definiert und ihnen eine Rolle in einem untergeordneten Knoten zuweist.

Sie können auch benutzerdefinierte Ansprüche in Authentication einrichten und diese Informationen dann aus der Variablen auth.token in einem beliebigen Firebase Security Rules abrufen.

Datendefinierte Attribute und Rollen

Diese Regeln funktionieren nur in Cloud Firestore und Realtime Database.

service cloud.firestore {
  match /databases/{database}/documents {
    // For attribute-based access control, Check a boolean `admin` attribute
    allow write: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.admin == true;
    allow read: true;

    // Alterntatively, for role-based access, assign specific roles to users
    match /some_collection/{document} {
     allow read: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.role == "Reader"
     allow write: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.role == "Writer"
   }
  }
}

{
  "rules": {
    "some_path": {
      "${subpath}": {
        //
        ".write": "root.child('users').child(auth.uid).child('role').val() === 'admin'",
        ".read": true
      }
    }
  }
}

Attribute und Rollen für benutzerdefinierte Ansprüche

Um diese Regeln zu implementieren, richten Sie benutzerdefinierte Ansprüche in Firebase Authentication ein und verwenden Sie die Ansprüche dann in Ihren Regeln.

service cloud.firestore {
  match /databases/{database}/documents {
    // For attribute-based access control, check for an administrator claim
    allow write: if request.auth.token.admin == true;
    allow read: true;

    // Alterntatively, for role-based access, assign specific roles to users
    match /some_collection/{document} {
     allow read: if request.auth.token.reader == "true";
     allow write: if request.auth.token.writer == "true";
   }
  }
}

{
  "rules": {
    "some_path": {
      "$uid": {
        // Create a custom claim for each role or group
        // you want to use
        ".write": "auth.uid !== null && auth.token.writer === true",
        ".read": "auth.uid !== null && auth.token.reader === true"
      }
    }
  }
}

service firebase.storage {
  // Allow reads if the group ID in your token matches the file metadata's `owner` property
  // Allow writes if the group ID is in the user's custom token
  match /files/{groupId}/{fileName} {
    allow read: if resource.metadata.owner == request.auth.token.groupId;
    allow write: if request.auth.token.groupId == groupId;
  }
}

Mandantenattribute

Um diese Regeln zu implementieren, richten Sie Multitenancy in Google Cloud Identity Platform (GCIP) ein und verwenden Sie dann den Mandanten in Ihren Regeln. In den folgenden Beispielen sind Schreibvorgänge von einem Nutzer in einem bestimmten Mandanten zulässig, z. B. tenant2-m6tyz.

service cloud.firestore {
  match /databases/{database}/documents {
    // For tenant-based access control, check for a tenantID
    allow write: if request.auth.token.firebase.tenant == 'tenant2-m6tyz';
    allow read: true;
  }
}

{
  "rules": {
    "some_path": {
      "$uid": {
        // Only allow reads and writes if user belongs to a specific tenant
        ".write": "auth.uid !== null && auth.token.firebase.tenant === 'tenant2-m6tyz'",
        ".read": "auth.uid !== null
      }
    }
  }
}

service firebase.storage {
  // Only allow reads and writes if user belongs to a specific tenant
  match /files/{tenantId}/{fileName} {
    allow read: if request.auth != null;
    allow write: if request.auth.token.firebase.tenant == tenantId;
  }
}