Sie können Firebase-Sicherheitsregeln verwenden, um neue Daten basierend auf vorhandenen Daten in Ihrer Datenbank oder Ihrem Speicher-Bucket bedingt zu schreiben. Sie können auch Regeln schreiben, die Datenvalidierungen erzwingen, indem Sie Schreibvorgänge basierend auf den neu geschriebenen Daten einschränken. Lesen Sie weiter, um mehr über Regeln zu erfahren, die vorhandene Daten nutzen, um Sicherheitsbedingungen zu schaffen.
Wählen Sie in jedem Abschnitt ein Produkt aus, um mehr über Datenvalidierungsregeln zu erfahren.
Einschränkungen für neue Daten
Cloud Firestore
Wenn Sie sicherstellen möchten, dass kein Dokument erstellt wird, das ein bestimmtes Feld enthält, können Sie das Feld in die allow
aufnehmen. Wenn Sie beispielsweise die Erstellung von Dokumenten verweigern möchten, die das ranking
Feld enthalten, müssen Sie dies in der create
verbieten.
service cloud.firestore {
match /databases/{database}/documents {
// Disallow
match /cities/{city} {
allow create: if !("ranking" in request.resource.data)
}
}
}
Echtzeitdatenbank
Wenn Sie sicherstellen möchten, dass Daten, die bestimmte Werte enthalten, nicht zu Ihrer Datenbank hinzugefügt werden, schließen Sie diesen Wert in Ihre Regeln ein und lassen ihn nicht für Schreibvorgänge zu. Wenn Sie beispielsweise alle Schreibvorgänge verweigern möchten, die ranking
enthalten, würden Sie Schreibvorgänge für alle Dokumente mit ranking
verbieten.
{
"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-Speicher
Wenn Sie sicherstellen möchten, dass keine Datei erstellt wird, die bestimmte Metadaten enthält, können Sie die Metadaten in die allow
einbeziehen. Wenn Sie beispielsweise die Erstellung von Dateien verweigern möchten, die ranking
Metadaten enthalten, würden Sie dies in der create
verbieten.
service firebase.storage {
match /b/{bucket}/o {
match /files/{allFiles=**} {
// Disallow
allow create: if !("ranking" in request.resource.metadata)
}
}
}
Vorhandene Daten in Firebase-Sicherheitsregeln verwenden
Cloud Firestore
Viele Apps speichern Zugriffskontrollinformationen als Felder für Dokumente in der Datenbank. Cloud Firestore-Sicherheitsregeln können den Zugriff basierend auf Dokumentdaten dynamisch zulassen oder verweigern:
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 resource
bezieht sich auf das angeforderte Dokument und resource.data
ist eine Zuordnung aller im Dokument gespeicherten Felder und Werte. Weitere Informationen zur resource
finden Sie in der Referenzdokumentation .
Beim Schreiben von Daten möchten Sie möglicherweise eingehende Daten mit vorhandenen Daten vergleichen. Auf diese Weise 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. Wenn Ihr Regelsatz in diesem Fall das ausstehende Schreiben zulässt, enthält die Variable request.resource
den zukünftigen Status des Dokuments. Bei update
, die nur eine Teilmenge der Dokumentfelder ändern, enthält die Variable request.resource
den ausstehenden Dokumentstatus nach dem Vorgang. Sie können die Feldwerte in request.resource
überprüfen, um unerwünschte oder inkonsistente Datenaktualisierungen zu verhindern:
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;
}
}
}
Echtzeitdatenbank
Verwenden Sie in der Echtzeitdatenbank .validate
Regeln, um Datenstrukturen durchzusetzen und das Format und den Inhalt von Daten zu validieren. Regeln führen .validate
Regeln aus, nachdem sie überprüft haben, ob eine .write
Regel Zugriff gewährt.
Die .validate
Regeln sind nicht kaskadierbar. Wenn eine Validierungsregel auf einem Pfad oder Unterpfad in der Regel fehlschlägt, wird der gesamte Schreibvorgang abgelehnt. Darüber hinaus prüfen die Validierungsdefinitionen nur auf Nicht-Null-Werte und ignorieren anschließend alle Anforderungen, die Daten löschen.
Berücksichtigen 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 oben genannten Regeln hätten folgende 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);
Ziel c
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];
Schnell
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);
AUSRUHEN
# 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-Speicher
Beim Auswerten von Regeln möchten Sie möglicherweise auch die Metadaten der Datei auswerten, die hochgeladen, heruntergeladen, geändert oder gelöscht wird. Auf diese Weise können Sie komplexe und leistungsstarke Regeln erstellen, die beispielsweise nur das Hochladen von Dateien mit bestimmten Inhaltstypen zulassen oder nur das Löschen von Dateien ab einer bestimmten Größe zulassen.
Das resource
enthält Schlüssel/Wert-Paare mit Dateimetadaten, die in einem Cloud Storage-Objekt angezeigt werden. Diese Eigenschaften können bei read
oder write
überprüft werden, um die Datenintegrität sicherzustellen. Das resource
überprüft Metadaten zu vorhandenen Dateien in Ihrem Cloud Storage-Bucket.
service firebase.storage {
match /b/{bucket}/o {
match /images {
match /{allImages=**} {
// 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
verwenden (z. B. Uploads, Metadatenaktualisierungen und Löschvorgänge). Das request.resource
Objekt ruft Metadaten aus der Datei ab, die geschrieben werden, wenn das write
zulässig ist.
Sie können diese beiden Werte verwenden, um unerwünschte oder inkonsistente Aktualisierungen zu verhindern oder Anwendungseinschränkungen wie Dateityp oder -größe durchzusetzen.
service firebase.storage {
match /b/{bucket}/o {
match /images {
// Cascade read to any image type at any path
match /{allImages=**} {
allow read;
}
// 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) File name (stored in imageId wildcard variable) is less than 32 characters
match /{imageId} {
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 Eigenschaften im resource
finden Sie in der Referenzdokumentation .