Lernen Sie die Kernsyntax der Sprache für Echtzeit-Datenbanksicherheitsregeln

Mit Firebase Realtime Database Security Rules können Sie den Zugriff auf Daten steuern, die in Ihrer Datenbank gespeichert sind. Mit der flexiblen Regelsyntax können Sie Regeln erstellen, die mit allem übereinstimmen, von allen Schreibvorgängen in Ihre Datenbank bis hin zu Operationen auf einzelnen Knoten.

Echtzeit-Datenbanksicherheitsregeln sind deklarative Konfigurationen für Ihre Datenbank. Das bedeutet, dass die Regeln getrennt von der Produktlogik definiert werden. Dies hat eine Reihe von Vorteilen: Clients sind nicht für die Durchsetzung der Sicherheit verantwortlich, fehlerhafte Implementierungen gefährden Ihre Daten nicht, und vielleicht am wichtigsten ist, dass kein zwischengeschalteter Schiedsrichter wie ein Server erforderlich ist, um Daten vor der Welt zu schützen.

In diesem Thema werden die grundlegende Syntax und Struktur von Echtzeit-Datenbanksicherheitsregeln beschrieben, die zum Erstellen vollständiger Regelsätze verwendet werden.

Strukturieren Sie Ihre Sicherheitsregeln

Echtzeit-Datenbanksicherheitsregeln bestehen aus JavaScript-ähnlichen Ausdrücken, die in einem JSON-Dokument enthalten sind. Die Struktur Ihrer Regeln sollte der Struktur der Daten folgen, die Sie in Ihrer Datenbank gespeichert haben.

Grundregeln identifizieren einen Satz von zu sichernden Knoten , die beteiligten Zugriffsmethoden (z. B. Lesen, Schreiben) und Bedingungen , unter denen der Zugriff entweder erlaubt oder verweigert wird. In den folgenden Beispielen sind unsere Bedingungen einfache true und false Aussagen, aber im nächsten Thema behandeln wir dynamischere Möglichkeiten, Bedingungen auszudrücken.

Wenn wir beispielsweise versuchen, einen child_node unter einem parent_node zu sichern, lautet die allgemeine Syntax:

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

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

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

Ihre Regeln sollten ähnlich aufgebaut sein. Hier ist eine Reihe von Regeln für die Nur-Lese-Sicherheit, die für diese Datenstruktur sinnvoll sein könnten. Dieses Beispiel veranschaulicht, wie wir Datenbankknoten angeben, für die Regeln gelten, und die Bedingungen für die Auswertung von Regeln an 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 Regeloperationen

Es gibt drei Arten von Regeln zum Erzwingen der Sicherheit basierend auf der Art der Operation, die für die Daten ausgeführt wird: .write , .read und .validate . Hier ist eine kurze Zusammenfassung ihrer Zwecke:

Platzhalter-Erfassungsvariablen

Alle Regelanweisungen zeigen auf Knoten. Eine Anweisung kann auf einen bestimmten Knoten zeigen oder $ -Platzhalter- Erfassungsvariablen verwenden, um auf Gruppen von Knoten auf einer Ebene der Hierarchie zu verweisen. Verwenden Sie diese Erfassungsvariablen, um den Wert von Knotenschlüsseln zur Verwendung in nachfolgenden Rules-Anweisungen zu speichern. Mit dieser Technik können Sie komplexere Rules- Bedingungen schreiben, worauf wir im nächsten Thema ausführlicher eingehen werden.

{
  "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 mit konstanten Pfadnamen verwendet werden. In diesem Beispiel verwenden wir die $other -Variable, um eine .validate -Regel zu deklarieren, die sicherstellt, dass widget außer title und color keine untergeordneten Elemente hat. Jeder Schreibvorgang, der dazu führen würde, dass zusätzliche untergeordnete Elemente erstellt würden, würde fehlschlagen.

{
  "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 }
    }
  }
}

Kaskade von Lese- und Schreibregeln

.read und .write Regeln funktionieren von oben nach unten, wobei flachere Regeln tiefere Regeln außer Kraft setzen. 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/ immer dann, wenn /foo/ ein untergeordnetes baz mit dem Wert true enthält. Die Regel ".read": false unter /foo/bar/ hat hier keine Wirkung, da der Zugriff nicht durch einen untergeordneten Pfad widerrufen werden kann.

Auch wenn es nicht sofort intuitiv erscheint, ist dies ein mächtiger Teil der Regelsprache und ermöglicht die Implementierung sehr komplexer Zugriffsrechte mit minimalem Aufwand. Dies wird später in diesem Handbuch veranschaulicht, wenn wir uns mit der benutzerbasierten Sicherheit befassen.

Beachten Sie, dass .validate Regeln nicht kaskadiert werden. Alle Validierungsregeln müssen auf allen Ebenen der Hierarchie erfüllt sein, damit ein Schreibvorgang zugelassen wird.

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 den Zugriff gewährt. Selbst wenn auf jeden betroffenen untergeordneten Pfad zugegriffen werden kann, schlägt das Lesen am übergeordneten Speicherort vollständig fehl. Betrachten Sie diese Struktur:

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

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

var db = firebase.database();
db.ref("records").once("value", function(snap) {
  // success method is not called
}, function(err) {
  // error callback triggered with PERMISSION_DENIED
});

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
}];

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
})

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
  });
});

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 dies einen PERMISSION_DENIED Fehler auslösen. Wenn wir diese Regel im Sicherheitssimulator in unserer Firebase-Konsole auswerten, sehen wir, dass der Lesevorgang verweigert wurde, weil keine Leseregel den Zugriff auf den /records/ -Pfad erlaubte. 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:

var db = firebase.database();
db.ref("records/rec1").once("value", function(snap) {
  // SUCCESS!
}, function(err) {
  // error callback is not called
});

FIRDatabaseReference *ref = [[FIRDatabase database] reference];
[[ref child:@"records/rec1"] observeSingleEventOfType:FEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
    // SUCCESS!
}];

var ref = FIRDatabase.database().reference()
ref.child("records/rec1").observeSingleEventOfType(.Value, withBlock: { snapshot in
    // SUCCESS!
})

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
  }
});

curl https://docs-examples.firebaseio.com/rest/records/rec1
# SUCCESS!

Überlappende Aussagen

Es ist möglich, dass mehr als eine Regel auf einen Knoten angewendet wird. Falls mehrere Regelausdrücke einen Knoten identifizieren, wird die Zugriffsmethode verweigert, 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 message1 Knoten verweigert, da die zweite Regel immer false ist, obwohl die erste Regel immer true ist.

Nächste Schritte

Sie können Ihr Verständnis der Sicherheitsregeln für Firebase-Echtzeitdatenbanken vertiefen:

• Lernen Sie das nächste Hauptkonzept der Rules-Sprache kennen, dynamische Bedingungen , mit denen Ihre Rules die Benutzerautorisierung überprüfen, vorhandene und eingehende Daten vergleichen, eingehende Daten validieren, die Struktur der vom Client kommenden Abfragen überprüfen und vieles mehr.

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