Datenvalidierung

Mit Firebase Security Rules können Sie neue Daten basierend auf vorhandenen Daten in Ihrer Datenbank oder Ihrem Storage-Bucket bedingt schreiben. Sie können auch Regeln schreiben, die Datenvalidierungen erzwingen, indem Schreibvorgänge basierend auf den neuen Daten, die geschrieben werden, eingeschränkt werden. Im Folgenden erfahren Sie mehr über Regeln, die vorhandene Daten verwenden, um Sicherheitsbedingungen zu erstellen.

Wählen Sie in jedem Abschnitt ein Produkt aus, um mehr über die Regeln für die Datenvalidierung zu erfahren.

Wenn Sie KI-Unterstützung benötigen, kopieren Sie den Prompt unten in Ihren KI-Coding-Agenten (z. B. Gemini in Android Studio, Antigravity, Claude Code, Codex und Cursor). Sie können den Prompt anpassen und mit Ihrem Agenten iterieren. Ausführliche Informationen zur Installation finden Sie unter Firebase-Agenten-Skills. 

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.

Einschränkungen für neue Daten

Cloud Firestore

Wenn Sie verhindern möchten, dass ein Dokument mit einem bestimmten Feld erstellt wird, können Sie das Feld in die allow-Bedingung aufnehmen. Wenn Sie beispielsweise die Erstellung von Dokumenten mit dem Feld ranking ablehnen möchten, würden Sie dies in der Bedingung create verbieten.

  service cloud.firestore {
    match /databases/{database}/documents {
      // Disallow
      match /cities/{city} {
        allow create: if !("ranking" in request.resource.data)
      }
    }
  }

Realtime Database

Wenn Sie sicherstellen möchten, dass Daten, die bestimmte Werte enthalten, nicht Ihrer Datenbank hinzugefügt werden, können Sie diesen Wert in Ihre Regeln aufnehmen und für Schreibvorgänge verbieten. Wenn Sie beispielsweise alle Schreibvorgänge ablehnen möchten, die ranking-Werte enthalten, würden Sie Schreibvorgänge für alle Dokumente mit ranking-Werten ablehnen.

  {
    "rules": {
      // Write is allowed for all paths
      ".write": true,
      // Allows writes only if new data doesn't include a `ranking` child value
      ".validate": "!newData.hasChild('ranking')
    }
  }

Cloud Storage

Wenn Sie sicherstellen möchten, dass eine Datei mit bestimmten Metadaten nicht erstellt wird, können Sie die Metadaten in die allow-Bedingung aufnehmen. Wenn Sie beispielsweise die Erstellung von Dateien mit ranking-Metadaten ablehnen möchten, würden Sie dies in der create-Bedingung verbieten.

  service firebase.storage {
    match /b/{bucket}/o {
      match /files/{fileName} {
      // Disallow
        allow create: if !("ranking" in request.resource.metadata)
      }
    }
  }

Vorhandene Daten in Firebase Security Rules verwenden

Cloud Firestore

Viele Apps speichern Informationen zur Zugriffssteuerung als Felder in Dokumenten in der Datenbank. Cloud Firestore Security Rules kann den Zugriff basierend auf Dokumentdaten dynamisch zulassen oder ablehnen:

  service cloud.firestore {
    match /databases/{database}/documents {
      // Allow the user to read data if the document has the 'visibility'
      // field set to 'public'
      match /cities/{city} {
        allow read: if resource.data.visibility == 'public';
      }
    }
  }

Die Variable resource verweist auf das angeforderte Dokument und resource.data ist eine Zuordnung aller Felder und Werte, die im Dokument gespeichert sind. Weitere Informationen zur Variable resource finden Sie in der Referenzdokumentation.

Beim Schreiben von Daten möchten Sie möglicherweise eingehende Daten mit vorhandenen Daten vergleichen. So können Sie beispielsweise sicherstellen, dass sich ein Feld nicht geändert hat, dass ein Feld nur um eins erhöht wurde oder dass der neue Wert mindestens eine Woche in der Zukunft liegt. In diesem Fall enthält die Variable request.resource den zukünftigen Status des Dokuments, wenn Ihr Regelsatz den ausstehenden Schreibvorgang zulässt. Bei update-Vorgängen, die nur einen Teil der Dokumentfelder ändern, enthält die Variable request.resource den Status des ausstehenden Dokuments nach dem Vorgang. Sie können die Feldwerte in request.resource prüfen, um unerwünschte oder inkonsistente Datenaktualisierungen zu vermeiden:

   service cloud.firestore {
     match /databases/{database}/documents {
      // Make sure all cities have a positive population and
      // the name is not changed
      match /cities/{city} {
        allow update: if request.resource.data.population > 0
                      && request.resource.data.name == resource.data.name;
      }
    }
  }

Realtime Database

In Realtime Database verwenden Sie .validate-Regeln, um Datenstrukturen zu erzwingen und das Format und den Inhalt von Daten zu validieren. Security Rules führt .validate-Regeln aus, nachdem geprüft wurde, ob eine .write-Regel Zugriff gewährt.

Die .validate-Regeln werden nicht kaskadiert. Wenn eine Validierungsregel für einen Pfad oder Unterpfad in der Regel fehlschlägt, wird der gesamte Schreibvorgang abgelehnt. Außerdem wird bei den Validierungsdefinitionen nur nach Werten gesucht, die nicht null sind. Alle Anfragen, bei denen Daten gelöscht werden, werden ignoriert.

Beachten Sie die folgenden .validate-Regeln:

  {
    "rules": {
      // write is allowed for all paths
      ".write": true,
      "widget": {
        // a valid widget must have attributes "color" and "size"
        // allows deleting widgets (since .validate is not applied to delete rules)
        ".validate": "newData.hasChildren(['color', 'size'])",
        "size": {
          // the value of "size" must be a number between 0 and 99
          ".validate": "newData.isNumber() &&
                        newData.val() >= 0 &&
                        newData.val() <= 99"
        },
        "color": {
          // the value of "color" must exist as a key in our mythical
          // /valid_colors/ index
          ".validate": "root.child('valid_colors/' + newData.val()).exists()"
        }
      }
    }
  }

Schreibanfragen an eine Datenbank mit den vorherigen Regeln haben die folgenden Ergebnisse:

JavaScript
var ref = db.ref("/widget");

// PERMISSION_DENIED: does not have children color and size
ref.set('foo');

// PERMISSION DENIED: does not have child color
ref.set({size: 22});

// PERMISSION_DENIED: size is not a number
ref.set({ size: 'foo', color: 'red' });

// SUCCESS (assuming 'blue' appears in our colors list)
ref.set({ size: 21, color: 'blue'});

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child('size').set(99);
Objective-C
Hinweis: Dieses Firebase-Produkt ist für das App Clip-Ziel nicht verfügbar. 
FIRDatabaseReference *ref = [[[FIRDatabase database] reference] child: @"widget"];

// PERMISSION_DENIED: does not have children color and size
[ref setValue: @"foo"];

// PERMISSION DENIED: does not have child color
[ref setValue: @{ @"size": @"foo" }];

// PERMISSION_DENIED: size is not a number
[ref setValue: @{ @"size": @"foo", @"color": @"red" }];

// SUCCESS (assuming 'blue' appears in our colors list)
[ref setValue: @{ @"size": @21, @"color": @"blue" }];

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
[[ref child:@"size"] setValue: @99];
Swift
Hinweis: Dieses Firebase-Produkt ist für das App Clip-Ziel nicht verfügbar. 
var ref = FIRDatabase.database().reference().child("widget")

// PERMISSION_DENIED: does not have children color and size
ref.setValue("foo")

// PERMISSION DENIED: does not have child color
ref.setValue(["size": "foo"])

// PERMISSION_DENIED: size is not a number
ref.setValue(["size": "foo", "color": "red"])

// SUCCESS (assuming 'blue' appears in our colors list)
ref.setValue(["size": 21, "color": "blue"])

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child("size").setValue(99);
Java
FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("widget");

// PERMISSION_DENIED: does not have children color and size
ref.setValue("foo");

// PERMISSION DENIED: does not have child color
ref.child("size").setValue(22);

// PERMISSION_DENIED: size is not a number
Map<String,Object> map = new HashMap<String, Object>();
map.put("size","foo");
map.put("color","red");
ref.setValue(map);

// SUCCESS (assuming 'blue' appears in our colors list)
map = new HashMap<String, Object>();
map.put("size", 21);
map.put("color","blue");
ref.setValue(map);

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child("size").setValue(99);
REST
# PERMISSION_DENIED: does not have children color and size
curl -X PUT -d 'foo' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# PERMISSION DENIED: does not have child color
curl -X PUT -d '{"size": 22}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# PERMISSION_DENIED: size is not a number
curl -X PUT -d '{"size": "foo", "color": "red"}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# SUCCESS (assuming 'blue' appears in our colors list)
curl -X PUT -d '{"size": 21, "color": "blue"}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# If the record already exists and has a color, this will
# succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
# will fail to validate
curl -X PUT -d '99' \
https://docs-examples.firebaseio.com/rest/securing-data/example/size.json

Cloud Storage

Beim Auswerten von Regeln können Sie auch die Metadaten der Datei auswerten, die hochgeladen, heruntergeladen, geändert oder gelöscht wird. So können Sie komplexe und leistungsstarke Regeln erstellen, mit denen Sie beispielsweise nur Dateien mit bestimmten Inhaltstypen hochladen oder nur Dateien ab einer bestimmten Größe löschen können.

Das Objekt resource enthält Schlüssel/Wert-Paare mit Dateimetadaten, die in einem Cloud Storage-Objekt angezeigt werden. Diese Attribute können bei read- oder write-Anfragen geprüft werden, um die Datenintegrität sicherzustellen. Das Objekt resource prüft Metadaten zu vorhandenen Dateien in Ihrem Cloud Storage-Bucket.

  service firebase.storage {
    match /b/{bucket}/o {
      match /images {
        match /{fileName} {
          // Allow reads if a custom 'visibility' field is set to 'public'
          allow read: if resource.metadata.visibility == 'public';
        }
      }
    }
  }

Sie können das request.resource-Objekt auch für write-Anfragen wie Uploads, Metadatenaktualisierungen und Löschvorgänge verwenden. Das Objekt request.resource ruft Metadaten aus der Datei ab, die geschrieben werden, wenn write zulässig ist.

Mit diesen beiden Werten können Sie unerwünschte oder inkonsistente Aktualisierungen verhindern oder Anwendungseinschränkungen wie Dateityp oder -größe erzwingen.

  service firebase.storage {
    match /b/{bucket}/o {
      match /images {
        // Allow write files to the path "images/*", subject to the constraints:
        // 1) File is less than 5MB
        // 2) Content type is an image
        // 3) Uploaded content type matches existing content type
        // 4) Filename (stored in imageId wildcard variable) is less than 32 characters
        match /{imageId} {
          allow read;
          allow write: if request.resource.size < 5 * 1024 * 1024
                       && request.resource.contentType.matches('image/.*')
                       && request.resource.contentType == resource.contentType
                       && imageId.size() < 32
        }
      }
    }
  }

Eine vollständige Liste der Properties im resource-Objekt finden Sie in der Referenzdokumentation.