Die grundlegende Syntax der Realtime Database-Sicherheitsregeln

Mit den Sicherheitsregeln der Firebase Realtime Database können Sie den Zugriff auf die in Ihrer Datenbank gespeicherten Daten steuern. Die flexible Regelsyntax ermöglicht es Ihnen, Regeln zu erstellen, die alles abdecken, von allen Schreibvorgängen in Ihrer Datenbank bis hin zu Vorgängen auf einzelnen Knoten.

Realtime Database-Sicherheitsregeln sind eine deklarative Konfiguration für Ihre Datenbank. Das bedeutet, dass die Regeln getrennt von der Produktlogik definiert werden. Das hat mehrere Vorteile: Clients sind nicht für die Durchsetzung der Sicherheit verantwortlich, fehlerhafte Implementierungen gefährden Ihre Daten nicht und, was vielleicht am wichtigsten ist, es ist kein Vermittler wie ein Server erforderlich, um Daten vor der Welt zu schützen.

In diesem Thema werden die grundlegende Syntax und Struktur der Realtime Database-Sicherheitsregeln beschrieben, die zum Erstellen vollständiger Regelsätze verwendet werden.

Sicherheitsregeln strukturieren

Sicherheitsregeln für die Realtime Database bestehen aus JavaScript-ähnlichen Ausdrücken, die in einem JSON-Dokument enthalten sind. Die Struktur Ihrer Regeln sollte der Struktur der Daten entsprechen, die Sie in Ihrer Datenbank gespeichert haben.

Grundlegende Regeln identifizieren eine Reihe von Knoten, die gesichert werden sollen, die beteiligten Zugriffsmethoden (z.B. Lesen, Schreiben) und die Bedingungen, unter denen der Zugriff entweder gewährt oder verweigert wird. In den folgenden Beispielen sind unsere Bedingungen einfache true- und false-Anweisungen. Im nächsten Thema werden wir jedoch dynamischere Möglichkeiten zum Ausdrücken von Bedingungen behandeln.

Wenn wir beispielsweise eine child_node unter einer parent_node sichern möchten, lautet die allgemeine Syntax:

{
  "rules": {
    "parent_node": {
      "child_node": {
        ".read": <condition>,
        ".write": <condition>,
        ".validate": <condition>,
      }
    }
  }
}

Wenden wir dieses Muster an. Angenommen, Sie haben eine Liste von Nachrichten und Daten, die so aussehen:

{
  "messages": {
    "message0": {
      "content": "Hello",
      "timestamp": 1405704370369
    },
    "message1": {
      "content": "Goodbye",
      "timestamp": 1405704395231
    },
    ...
  }
}

Ihre Regeln sollten ähnlich strukturiert sein. Hier ist ein Satz von Regeln für die schreibgeschützte Sicherheit, die für diese Datenstruktur sinnvoll sein könnten. In diesem Beispiel wird gezeigt, wie wir Datenbankknoten angeben, für die Regeln gelten, und die Bedingungen für die Auswertung von Regeln auf diesen Knoten.

{
  "rules": {
    // For requests to access the 'messages' node...
    "messages": {
      // ...and the individual wildcarded 'message' nodes beneath
      // (we'll cover wildcarding variables more a bit later)....
      "$message": {

        // For each message, allow a read operation if <condition>. In this
        // case, we specify our condition as "true", so read access is always granted.
        ".read": "true",

        // For read-only behavior, we specify that for write operations, our
        // condition is false.
        ".write": "false"
      }
    }
  }
}

Grundlegende Regelvorgänge

Es gibt drei Arten von Regeln, um die Sicherheit basierend auf der Art des Vorgangs zu erzwingen, der für die Daten ausgeführt wird: .write, .read und .validate. Hier eine kurze Zusammenfassung der Zwecke:

Regeltypen
.read Beschreibt, ob und wann Daten von Nutzern gelesen werden dürfen.
.write Beschreibt, ob und wann Daten geschrieben werden dürfen.
.validate Definiert, wie ein korrekt formatierter Wert aussieht, ob er untergeordnete Attribute hat und welchen Datentyp er hat.

Platzhalter-Erfassungsvariablen

Alle Regelanweisungen verweisen auf Knoten. Eine Anweisung kann auf einen bestimmten Knoten verweisen oder $-Platzhalter-Erfassungsvariablen verwenden, um auf Knotensätze auf einer Ebene der Hierarchie zu verweisen. Verwenden Sie diese Erfassungsvariablen, um den Wert von Knotenschlüsseln für die Verwendung in nachfolgenden Regelanweisungen zu speichern. Mit dieser Methode können Sie komplexere Security Rules-Bedingungen schreiben. Darauf gehen wir im nächsten Thema näher ein.

{
  "rules": {
    "rooms": {
      // this rule applies to any child of /rooms/, the key for each room id
      // is stored inside $room_id variable for reference
      "$room_id": {
        "topic": {
          // the room's topic can be changed if the room id has "public" in it
          ".write": "$room_id.contains('public')"
        }
      }
    }
  }
}

Die dynamischen $-Variablen können auch parallel zu konstanten Pfadnamen verwendet werden. In diesem Beispiel verwenden wir die Variable $other, um eine .validate-Regel zu deklarieren, die dafür sorgt, dass widget keine anderen untergeordneten Elemente als title und color hat. Jeder Schreibvorgang, der zur Erstellung zusätzlicher untergeordneter Elemente führen würde, schlägt fehl.

{
  "rules": {
    "widget": {
      // a widget can have a title or color attribute
      "title": { ".validate": true },
      "color": { ".validate": true },

      // but no other child paths are allowed
      // in this case, $other means any key excluding "title" and "color"
      "$other": { ".validate": false }
    }
  }
}

Kaskadierung von Lese- und Schreibregeln

.read- und .write-Regeln werden von oben nach unten angewendet, wobei Regeln auf höherer Ebene Regeln auf tieferer Ebene überschreiben. Wenn eine Regel Lese- oder Schreibberechtigungen für einen bestimmten Pfad gewährt, gewährt sie auch Zugriff auf alle untergeordneten Knoten darunter. Betrachten Sie die folgende Struktur:

{
  "rules": {
     "foo": {
        // allows read to /foo/*
        ".read": "data.child('baz').val() === true",
        "bar": {
          /* ignored, since read was allowed already */
          ".read": false
        }
     }
  }
}

Diese Sicherheitsstruktur ermöglicht das Lesen von /bar/, wenn /foo/ ein untergeordnetes Element baz mit dem Wert true enthält. Die Regel ".read": false unter /foo/bar/ hat hier keine Auswirkung, da der Zugriff nicht über einen untergeordneten Pfad widerrufen werden kann.

Auch wenn es nicht sofort intuitiv erscheint, ist dies ein leistungsstarker Teil der Regelsprache, mit dem sich sehr komplexe Zugriffsberechtigungen mit minimalem Aufwand implementieren lassen. Dies wird später in diesem Leitfaden im Abschnitt zur nutzerbasierten Sicherheit veranschaulicht.

Beachten Sie, dass .validate-Regeln nicht kaskadiert werden. Alle Validierungsregeln müssen auf allen Ebenen der Hierarchie erfüllt sein, damit ein Schreibvorgang zulässig ist.

Regeln sind keine Filter

Regeln werden atomar angewendet. Das bedeutet, dass ein Lese- oder Schreibvorgang sofort fehlschlägt, wenn es an diesem Speicherort oder an einem übergeordneten Speicherort keine Regel gibt, die Zugriff gewährt. Auch wenn alle betroffenen untergeordneten Pfade zugänglich sind, schlägt das Lesen am übergeordneten Speicherort vollständig fehl. Betrachten Sie diese Struktur:

{
  "rules": {
    "records": {
      "rec1": {
        ".read": true
      },
      "rec2": {
        ".read": false
      }
    }
  }
}

Ohne zu wissen, dass Regeln atomar ausgewertet werden, könnte es so aussehen, als würde das Abrufen des Pfads /records/ den Wert rec1, aber nicht rec2 zurückgeben. Das tatsächliche Ergebnis ist jedoch ein Fehler:

JavaScript
var db = firebase.database();
db.ref("records").once("value", function(snap) {
  // success method is not called
}, function(err) {
  // error callback triggered with PERMISSION_DENIED
});
Objective-C
Hinweis: Dieses Firebase-Produkt ist für das App Clip-Ziel nicht verfügbar.
FIRDatabaseReference *ref = [[FIRDatabase database] reference];
[[_ref child:@"records"] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
  // success block is not called
} withCancelBlock:^(NSError * _Nonnull error) {
  // cancel block triggered with PERMISSION_DENIED
}];
Swift
Hinweis: Dieses Firebase-Produkt ist für das App Clip-Ziel nicht verfügbar.
var ref = FIRDatabase.database().reference()
ref.child("records").observeSingleEventOfType(.Value, withBlock: { snapshot in
    // success block is not called
}, withCancelBlock: { error in
    // cancel block triggered with PERMISSION_DENIED
})
Java
FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("records");
ref.addListenerForSingleValueEvent(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot snapshot) {
    // success method is not called
  }

  @Override
  public void onCancelled(FirebaseError firebaseError) {
    // error callback triggered with PERMISSION_DENIED
  });
});
REST
curl https://docs-examples.firebaseio.com/rest/records/
# response returns a PERMISSION_DENIED error

Da der Lesevorgang bei /records/ atomar ist und es keine Leseregel gibt, die Zugriff auf alle Daten unter /records/ gewährt, wird ein PERMISSION_DENIED-Fehler ausgegeben. Wenn wir diese Regel im Sicherheitssimulator in der Firebase-Konsole auswerten, sehen wir, dass der Lesevorgang abgelehnt wurde, weil keine Leseregel den Zugriff auf den Pfad /records/ erlaubt hat. Beachten Sie jedoch, dass die Regel für rec1 nie ausgewertet wurde, da sie sich nicht im angeforderten Pfad befand. Um rec1 abzurufen, müssten wir direkt darauf zugreifen:

JavaScript
var db = firebase.database();
db.ref("records/rec1").once("value", function(snap) {
  // SUCCESS!
}, function(err) {
  // error callback is not called
});
Objective-C
Hinweis: Dieses Firebase-Produkt ist für das App Clip-Ziel nicht verfügbar.
FIRDatabaseReference *ref = [[FIRDatabase database] reference];
[[ref child:@"records/rec1"] observeSingleEventOfType:FEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
    // SUCCESS!
}];
Swift
Hinweis: Dieses Firebase-Produkt ist für das App Clip-Ziel nicht verfügbar.
var ref = FIRDatabase.database().reference()
ref.child("records/rec1").observeSingleEventOfType(.Value, withBlock: { snapshot in
    // SUCCESS!
})
Java
FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("records/rec1");
ref.addListenerForSingleValueEvent(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot snapshot) {
    // SUCCESS!
  }

  @Override
  public void onCancelled(FirebaseError firebaseError) {
    // error callback is not called
  }
});
REST
curl https://docs-examples.firebaseio.com/rest/records/rec1
# SUCCESS!

Sich überschneidende Aussagen

Es ist möglich, dass mehrere Regeln auf einen Knoten angewendet werden. Wenn ein Knoten durch mehrere Regelausdrücke identifiziert wird, wird die Zugriffsmethode abgelehnt, wenn eine der Bedingungen false ist:

{
  "rules": {
    "messages": {
      // A rule expression that applies to all nodes in the 'messages' node
      "$message": {
        ".read": "true",
        ".write": "true"
      },
      // A second rule expression applying specifically to the 'message1` node
      "message1": {
        ".read": "false",
        ".write": "false"
      }
    }
  }
}

Im obigen Beispiel werden Lesevorgänge für den Knoten message1 abgelehnt, da die zweite Regel immer false ist, obwohl die erste Regel immer true ist.

Nächste Schritte

So können Sie Ihr Verständnis der Sicherheitsregeln für die Firebase Realtime Database vertiefen:

  • Lernen Sie das nächste wichtige Konzept der Sprache Security Rules kennen: dynamische Bedingungen. Damit können Sie in Security Rules die Nutzerautorisierung prüfen, vorhandene und eingehende Daten vergleichen, eingehende Daten validieren, die Struktur von Abfragen vom Client prüfen und vieles mehr.

  • Sehen Sie sich typische Sicherheitsanwendungsfälle und die entsprechenden Definitionen von Firebase-Sicherheitsregeln an.