Bezpieczne zapytania o dane

Na tej stronie omawiamy pojęcia z zakresu Tworzenie struktury reguł zabezpieczeń Pisanie warunków reguł zabezpieczeń wyjaśniających, jak Cloud Firestore Security Rules wchodzi w interakcje z zapytaniami. W tym artykule omawiamy szczegółowo, jak reguły zabezpieczeń wpływają na zapytania, które możesz tworzyć, oraz wyjaśniamy, jak zapewnić, aby zapytania stosowały te same ograniczenia co reguły zabezpieczeń. Ta strona też opisuje, jak pisać reguły zabezpieczeń, które zezwalają na zapytania na podstawie zapytania lub je odrzucają. właściwości takich jak limit i orderBy.

Reguły nie są filtrami

Tworząc zapytania służące do pobierania dokumentów, pamiętaj, że reguły zabezpieczeń a nie filtry – zapytania dotyczą wszystkich albo nie mają żadnej wartości. Aby zaoszczędzić Twój czas i zasoby, Funkcja Cloud Firestore ocenia zapytanie względem potencjalnego zbioru wyników zamiast rzeczywistej wartości pól dla wszystkich dokumentów. Gdyby zapytanie mogło mogą zwrócić dokumenty, których klient nie ma uprawnień do odczytu, nie powiedzie się.

Zapytania i reguły zabezpieczeń

Jak widać na przykładach poniżej, musisz tworzyć zapytania, które będą pasować do ograniczeń określonych w regułach zabezpieczeń.

Zabezpieczanie dokumentów i wykonywanie na nich zapytań na podstawie zasad auth.uid

Ten przykład pokazuje, jak napisać zapytanie służące do pobierania dokumentów chronionych przez regułę zabezpieczeń. Załóżmy, że mamy bazę danych zawierającą zbiór story dokumenty:

/stories/{storyid}

{
  title: "A Great Story",
  content: "Once upon a time...",
  author: "some_auth_id",
  published: false
}

Oprócz pól title i content każdy dokument zawiera pola author i published, które służą do kontroli dostępu. W tych przykładach zakładamy, aplikacja używa uwierzytelniania Firebase do ustawienia pola author. z identyfikatorem UID użytkownika, który utworzył dokument. Firebase Uwierzytelnianie wypełnia też zmienną request.auth w i zasad bezpieczeństwa.

Ta reguła zabezpieczeń korzysta z request.auth oraz Zmienne resource.data, które ograniczają dostęp do odczytu i zapisu dla poszczególnych story do autora:

service cloud.firestore {
  match /databases/{database}/documents {
    match /stories/{storyid} {
      // Only the authenticated user who authored the document can read or write
      allow read, write: if request.auth != null && request.auth.uid == resource.data.author;
    }
  }
}

Załóżmy, że Twoja aplikacja zawiera stronę, na której użytkownik widzi listę story stworzonych przez nich dokumentów. Możesz kierować się tymi informacjami: za pomocą zapytania. To zapytanie się nie powiedzie, ponieważ nie zawiera tych samych ograniczeń co reguły zabezpieczeń:

Nieprawidłowe: ograniczenia zapytań nie pasują do ograniczeń reguł bezpieczeństwa

// This query will fail
db.collection("stories").get()

Zapytanie nie zostaje wykonane, nawet jeśli bieżący użytkownik jest autorem każdego story dokument. Dzieje się tak, ponieważ Cloud Firestore zastosuje Twoje reguły zabezpieczeń i sprawdzi zapytanie ze zbiorem potencjalnych wyników, a nie z rzeczywistymi właściwościami funkcji dokumentów w bazie danych. Jeśli zapytanie może potencjalnie obejmować dokumenty które naruszają Twoje reguły zabezpieczeń, zapytanie zakończy się niepowodzeniem.

Poniższe zapytanie się sprawdza, ponieważ zawiera to samo w polu author jako reguły zabezpieczeń:

Prawidłowe: ograniczenia zapytań pasują do zabezpieczeń. ograniczenia reguł

var user = firebase.auth().currentUser;

db.collection("stories").where("author", "==", user.uid).get()

Zabezpieczanie dokumentów i wykonywanie na nich zapytań na podstawie pól

Aby jeszcze lepiej zademonstrować współzależność między zapytaniami a regułami, funkcja zabezpieczeń poniższe reguły rozszerzają uprawnienia do odczytu kolekcji stories, aby każdy użytkownik mógł odczytywano dokumenty (story), w których pole published ma wartość true.

service cloud.firestore {
  match /databases/{database}/documents {
    match /stories/{storyid} {
      // Anyone can read a published story; only story authors can read unpublished stories
      allow read: if resource.data.published == true || (request.auth != null && request.auth.uid == resource.data.author);
      // Only story authors can write
      allow write: if request.auth != null && request.auth.uid == resource.data.author;
    }
  }
}

Zapytanie o opublikowane strony musi zawierać te same ograniczenia co zabezpieczenia reguły:

db.collection("stories").where("published", "==", true).get()

Ograniczenie zapytania .where("published", "==", true) gwarantuje, że resource.data.published ma wartość true dla dowolnego wyniku. Dlatego to zapytanie jest zgodna z regułami zabezpieczeń i może odczytywać dane.

Zapytania: OR

Podczas oceny zapytania logicznego OR (or, in lub array-contains-any) w porównaniu z zestawem reguł, Cloud Firestore ocenia każdą wartość porównawczą oddzielnie. Każda wartość porównania musi spełniać ograniczenia reguły zabezpieczeń. Na przykład w przypadku tej reguły:

match /mydocuments/{doc} {
  allow read: if resource.data.x > 5;
}

Błąd: zapytanie nie gwarantuje, że: x > 5 dla wszystkich potencjalnych dokumentów

// These queries will fail
query(db.collection("mydocuments"),
      or(where("x", "==", 1),
         where("x", "==", 6)
      )
    )

query(db.collection("mydocuments"),
      where("x", "in", [1, 3, 6, 42, 99])
    )

Prawidłowy: zapytanie gwarantuje, że: x > 5 dla wszystkich potencjalnych dokumentów

query(db.collection("mydocuments"),
      or(where("x", "==", 6),
         where("x", "==", 42)
      )
    )

query(db.collection("mydocuments"),
      where("x", "in", [6, 42, 99, 105, 200])
    )

Ocena ograniczeń w zapytaniach

Twoje reguły zabezpieczeń mogą też akceptować lub odrzucać zapytania na podstawie swoich ograniczeń. Zmienna request.query zawiera te elementy: limit, offset, i orderBy właściwości zapytania. Na przykład reguły zabezpieczeń może odrzucać zapytania, które nie ograniczają maksymalnej liczby dokumentów pobrane do określonego zakresu:

allow list: if request.query.limit <= 10;

Poniższy zestaw reguł pokazuje, jak pisać reguły zabezpieczeń, które oceniają na zapytania. W tym przykładzie rozszerzamy poprzedni zbiór reguł stories o te zmiany:

  • Zestaw reguł dzieli regułę odczytu na reguły dla get i list.
  • Reguła get ogranicza wyszukiwanie pojedynczych dokumentów do dokumentów publicznych lub dokumentów utworzonych przez użytkownika.
  • Reguła list stosuje te same ograniczenia co reguła get, ale w przypadku zapytań. Sprawdza też limit zapytań, a następnie odrzuca każde zapytanie bez limitu lub z limitem większym niż 10.
  • Zestaw reguł definiuje funkcję authorOrPublished(), aby uniknąć duplikowania kodu.
service cloud.firestore {

  match /databases/{database}/documents {

    match /stories/{storyid} {

      // Returns `true` if the requested story is 'published'
      // or the user authored the story
      function authorOrPublished() {
        return resource.data.published == true || request.auth.uid == resource.data.author;
      }

      // Deny any query not limited to 10 or fewer documents
      // Anyone can query published stories
      // Authors can query their unpublished stories
      allow list: if request.query.limit <= 10 &&
                     authorOrPublished();

      // Anyone can retrieve a published story
      // Only a story's author can retrieve an unpublished story
      allow get: if authorOrPublished();

      // Only a story's author can write to a story
      allow write: if request.auth.uid == resource.data.author;
    }

  }
}

Zapytania dotyczące grup kolekcji i reguły zabezpieczeń

Domyślnie zapytania są ograniczone do 1 kolekcji i pobierają wyniki tylko z tej kolekcji. Na zapytania dotyczące grup kolekcji, możesz pobiera wyniki z grupy kolekcji złożonej ze wszystkich kolekcji z atrybutem ten sam identyfikator. W tej sekcji dowiesz się, jak zabezpieczyć zapytania dotyczące grupy kolekcji. przy użyciu reguł zabezpieczeń.

Zabezpieczanie dokumentów i wykonywanie na nich zapytań na podstawie grup kolekcji

W regułach zabezpieczeń musisz wyraźnie zezwolić na zapytania dotyczące grupy zbiorów danych, tworząc regułę dla tej grupy:

  1. Upewnij się, że rules_version = '2'; jest pierwszym wierszem zestawu reguł. Gromadzenie danych Zapytania grupowe wymagają parametru nowy rekurencyjny symbol wieloznaczny {name=**} dla bezpieczeństwa reguły w wersji 2.
  2. Napisz regułę dla grupy kolekcji za pomocą match /{path=**}/[COLLECTION_ID]/{doc}

Weźmy na przykład forum podzielone na dokumenty forum zawierające posts podkolekcji:

/forums/{forumid}/posts/{postid}

{
  author: "some_auth_id",
  authorname: "some_username",
  content: "I just read a great story.",
}

W tej aplikacji ich właściciele mogą edytować posty, a ich użytkownicy mogą je odczytać uwierzytelnieni użytkownicy:

service cloud.firestore {
  match /databases/{database}/documents {
    match /forums/{forumid}/posts/{post} {
      // Only authenticated users can read
      allow read: if request.auth != null;
      // Only the post author can write
      allow write: if request.auth != null && request.auth.uid == resource.data.author;
    }
  }
}

Każdy uwierzytelniony użytkownik może pobierać posty z dowolnego forum:

db.collection("forums/technology/posts").get()

Co jednak w sytuacji, gdy chcesz pokazywać bieżącemu użytkownikowi jego posty na wszystkich forach? Za pomocą zapytania dotyczącego grupy kolekcji możesz pobrać wyniki ze wszystkich kolekcji posts:

var user = firebase.auth().currentUser;

db.collectionGroup("posts").where("author", "==", user.uid).get()

W regułach zabezpieczeń musisz zezwolić na wykonywanie tego zapytania przez napisz regułę odczytu lub listy dla grupy kolekcji posts:

rules_version = '2';
service cloud.firestore {

  match /databases/{database}/documents {
    // Authenticated users can query the posts collection group
    // Applies to collection queries, collection group queries, and
    // single document retrievals
    match /{path=**}/posts/{post} {
      allow read: if request.auth != null;
    }
    match /forums/{forumid}/posts/{postid} {
      // Only a post's author can write to a post
      allow write: if request.auth != null && request.auth.uid == resource.data.author;

    }
  }
}

Pamiętaj jednak, że te reguły będą dotyczyć wszystkich kolekcji o identyfikatorze posts, bez względu na hierarchię. Na przykład te reguły mają zastosowanie do wszystkich posts kolekcje:

  • /posts/{postid}
  • /forums/{forumid}/posts/{postid}
  • /forums/{forumid}/subforum/{subforumid}/posts/{postid}

Zabezpiecz zapytania dotyczące grup kolekcji na podstawie pola

Podobnie jak w przypadku zapytań w ramach pojedynczego zbioru zapytania dotyczące grup kolekcji muszą również spełniać ograniczeń ustawionych przez reguły zabezpieczeń. Możemy na przykład dodać pole published do każdego wpisu na forum, tak jak w przypadku pola stories w powyższym przykładzie:

/forums/{forumid}/posts/{postid}

{
  author: "some_auth_id",
  authorname: "some_username",
  content: "I just read a great story.",
  published: false
}

Możemy wtedy napisać reguły dla grupy kolekcji posts na podstawie Stan published i post author:

rules_version = '2';
service cloud.firestore {

  match /databases/{database}/documents {

    // Returns `true` if the requested post is 'published'
    // or the user authored the post
    function authorOrPublished() {
      return resource.data.published == true || request.auth.uid == resource.data.author;
    }

    match /{path=**}/posts/{post} {

      // Anyone can query published posts
      // Authors can query their unpublished posts
      allow list: if authorOrPublished();

      // Anyone can retrieve a published post
      // Authors can retrieve an unpublished post
      allow get: if authorOrPublished();
    }

    match /forums/{forumid}/posts/{postid} {
      // Only a post's author can write to a post
      allow write: if request.auth.uid == resource.data.author;
    }
  }
}

Przy użyciu tych reguł klienty internetowe, Apple i Android mogą wykonywać te zapytania:

  • Każdy może pobrać opublikowane posty na forum:

    db.collection("forums/technology/posts").where('published', '==', true).get()

  • Każdy może pobrać posty autora opublikowane na wszystkich forach:

    db.collectionGroup("posts").where("author", "==", "some_auth_id").where('published', '==', true).get()

  • Autorzy mogą pobierać wszystkie swoje opublikowane i nieopublikowane posty ze wszystkich fora:

    var user = firebase.auth().currentUser;

db.collectionGroup("posts").where("author", "==", user.uid).get()

Zabezpiecz dokumenty i wyszukuj dokumenty na podstawie grupy kolekcji i ścieżki dokumentu

W niektórych przypadkach możesz chcieć ograniczyć zapytania dotyczące grup kolekcji na podstawie ścieżki do dokumentu. Aby utworzyć te ograniczenia, możesz użyć tych samych technik dla: zabezpieczanie dokumentów i wykonywanie dotyczących ich zapytań na podstawie pól.

Rozważ użycie aplikacji, która śledzi transakcje każdego użytkownika z kilku giełd i giełd kryptowalut:

/users/{identyfikator użytkownika}/Wymiana/{identyfikator-usługi}/transactions/{transaction}

{
  amount: 100,
  exchange: 'some_exchange_name',
  timestamp: April 1, 2019 at 12:00:00 PM UTC-7,
  user: "some_auth_id",
}

Zwróć uwagę na pole user. Chociaż wiemy, do którego użytkownika transaction należy ze ścieżki dokumentu, duplikujemy te informacje w każdej transaction, ponieważ pozwala nam robić 2 rzeczy:

  • Twórz zapytania dotyczące grup kolekcji ograniczone do dokumentów zawierających konkretny element /users/{userid} w ścieżce dokumentu. Przykład:

    var user = firebase.auth().currentUser;
// Return current user's last five transactions across all exchanges
db.collectionGroup("transactions").where("user", "==", user).orderBy('timestamp').limit(5)

  • Egzekwuj to ograniczenie do wszystkich zapytań w kolekcji transactions tak, aby jeden użytkownik nie mógł pobierać dokumentów transaction innego użytkownika.

To ograniczenie egzekwujemy w naszych regułach zabezpieczeń i uwzględniamy weryfikację danych dla pola user:

rules_version = '2';
service cloud.firestore {

  match /databases/{database}/documents {

    match /{path=**}/transactions/{transaction} {
      // Authenticated users can retrieve only their own transactions
      allow read: if resource.data.user == request.auth.uid;
    }

    match /users/{userid}/exchange/{exchangeid}/transactions/{transaction} {
      // Authenticated users can write to their own transactions subcollections
      // Writes must populate the user field with the correct auth id
      allow write: if userid == request.auth.uid && request.data.user == request.auth.uid
    }
  }
}

Dalsze kroki