Règles de sécurité et Firebase Authentication

Firebase Security Rules permettent de contrôler les accès et de valider les données dans un format compatible plusieurs niveaux de complexité. Créer des systèmes d’accès basés sur les utilisateurs et sur les rôles qui assurent à vos utilisateurs sécurité des données, utilisez Firebase Authentication avec Firebase Security Rules

Identifier les utilisateurs

Authentication identifie les utilisateurs qui demandent à accéder à vos données et vous indique les informations comme une variable exploitable dans vos règles. La variable auth contient les informations suivantes:

• uid : ID utilisateur unique attribué à l'utilisateur à l'origine de la requête.
• token:carte des valeurs collectées par Authentication.

La variable auth.token contient les valeurs suivantes:

Si vous souhaitez ajouter des attributs d'authentification personnalisés, auth.token contient également les revendications personnalisées que vous spécifiez.

Lorsque l'utilisateur qui demande l'accès n'est pas connecté, la variable auth est null. Vous pouvez l'utiliser dans vos règles si, par exemple, vous souhaitez limiter le nombre de lectures l'accès aux utilisateurs authentifiés : auth != null. Toutefois, nous vous recommandons généralement de limiter davantage l'accès en écriture.

Pour en savoir plus sur la variable auth, consultez la documentation de référence pour Cloud Firestore, Realtime Database et Cloud Storage.

Exploiter les informations utilisateur dans les règles

En pratique, l'utilisation d'informations authentifiées dans vos règles plus puissants et plus flexibles. Vous pouvez contrôler l'accès aux données en fonction des utilisateurs l'identité.

Dans vos règles, définissez la manière dont les informations de la variable auth, c'est-à-dire la informations utilisateur du demandeur : correspond aux informations utilisateur associées au les données demandées.

Par exemple, votre application peut vouloir s'assurer que les utilisateurs ne peuvent lire et écrire que leurs vos propres données. Dans ce cas, vous devez établir une correspondance entre La variable auth.uid et l'ID utilisateur sur les données demandées:

service cloud.firestore {
  match /databases/{database}/documents {
    // Make sure the uid of the requesting user matches name of the user
    // document. The wildcard expression {userId} makes the userId variable
    // available in rules.
    match /users/{userId} {
      allow read, write: if request.auth != null && request.auth.uid == userId;
    }
  }
}

{
  "rules": {
    "users": {
      "$userId": {
        // grants write access to the owner of this user account
        // whose uid must exactly match the key ($userId)
        ".write": "$userId === auth.uid"
      }
    }
  }
}

service firebase.storage {
  // Only a user can upload their file, but anyone can view it
  match /users/{userId}/{fileName} {
    allow read;
    allow write: if request.auth != null && request.auth.uid == userId;
  }
}

Définir des informations utilisateur personnalisées

Vous pouvez exploiter davantage la variable auth pour définir les champs personnalisés attribués aux utilisateurs de votre application.

Par exemple, supposons que vous vouliez créer un compte "admin" qui autorise l'accès en écriture sur certains chemins. Vous attribueriez cet attribut à des utilisateurs, et puis l'exploiter dans les règles accordant l'accès sur les chemins.

Dans Cloud Firestore, vous pouvez ajouter un champ personnalisé aux utilisateurs des documents et récupérer la valeur de ce champ avec une lecture intégrée dans vos règles. Ainsi, la gestion de l'authentification doit ressembler à l'exemple suivant:

service cloud.firestore {
  match /databases/{database}/documents/some_collection: {
    // Remember that, in Cloud Firestore, reads embedded in your rules are billed operations
    write: if request.auth != null && get(/databases/(database)/documents/users/$(request.auth.uid)).data.admin == true;
    read: if request.auth != null;
  }
}

Vous pouvez accéder aux revendications personnalisées dans Rules après avoir créé des revendications personnalisées dans Authentication. Vous pouvez ensuite référencer ces revendications personnalisées à l'aide de la variable auth.token.

service cloud.firestore {
  match /databases/{database}/documents {
    // For attribute-based access control, check for an admin claim
    allow write: if request.auth.token.admin == true;
    allow read: true;

    // Alterntatively, for role-based access, assign specific roles to users
    match /some_collection/{document} {
     allow read: if request.auth.token.reader == "true";
     allow write: if request.auth.token.writer == "true";
   }
  }
}

{
  "rules": {
    "some_path/$sub_path": {
      // Create a custom claim for the admin role
      ".write": "auth.uid !== null && auth.token.writer === true"
      ".read": "auth.uid !== null"
      }
    }
  }

service firebase.storage {
  // Create a custom claim for the admin role
  match /files/{fileName} {
    allow read: if request.auth.uid != null;
    allow write: if request.auth.token.admin == true;
  }
}

Pour voir d'autres exemples d'utilisation de Rules de base avec Authentication, consultez Règles de sécurité de base.