Evite las reglas inseguras

Utilice esta guía para comprender las vulnerabilidades comunes en las configuraciones de las reglas de seguridad de Firebase, revisar y proteger mejor sus propias reglas y probar los cambios antes de implementarlos.

Si recibe una alerta de que sus datos no están protegidos adecuadamente, revise estos errores que se cometen comúnmente y actualice las reglas vulnerables.

Acceda a sus reglas de seguridad de Firebase

Para ver sus reglas existentes, use Firebase CLI o Firebase console. Asegúrese de editar sus reglas utilizando el mismo método, de manera consistente, para evitar sobrescribir actualizaciones por error. Si no está seguro de si sus reglas definidas localmente reflejan las actualizaciones más recientes, Firebase console siempre muestra la versión implementada más recientemente de sus reglas de seguridad de Firebase.

Para acceder a sus reglas desde Firebase console , seleccione su proyecto, luego navegue hasta Realtime Database , Cloud Firestore o Storage . Haga clic en Reglas una vez que esté en la base de datos o depósito de almacenamiento correcto.

Para acceder a sus reglas desde Firebase CLI, vaya al archivo de reglas anotado en su archivo firebase.json .

Comprender las reglas de seguridad de Firebase

Las reglas de seguridad de Firebase protegen sus datos de usuarios malintencionados. Cuando creas una instancia de base de datos o un depósito de Cloud Storage en Firebase console, puedes elegir denegar el acceso a todos los usuarios ( modo bloqueado ) o otorgar acceso a todos los usuarios ( modo de prueba ). Si bien es posible que desee una configuración más abierta durante el desarrollo, asegúrese de tomarse el tiempo para configurar correctamente sus reglas y proteger sus datos antes de implementar su aplicación.

Mientras desarrollas tu aplicación y pruebas diferentes configuraciones para tus reglas, usa uno de los emuladores locales de Firebase para ejecutar tu aplicación en un entorno de desarrollo local.

Escenarios comunes con reglas inseguras

Las reglas que haya configurado de forma predeterminada o cuando trabajó inicialmente en el desarrollo de su aplicación deben revisarse y actualizarse antes de implementarla. Asegúrese de proteger adecuadamente los datos de sus usuarios evitando los siguientes errores comunes.

Acceso abierto

Al configurar su proyecto de Firebase, es posible que haya establecido sus reglas para permitir el acceso abierto durante el desarrollo. Podrías pensar que eres la única persona que utiliza tu aplicación, pero si la has implementado, estará disponible en Internet. Si no está autenticando usuarios ni configurando reglas de seguridad, cualquiera que adivine el ID de su proyecto puede robar, modificar o eliminar los datos.

// Allow read/write access to all users under any conditions
// Warning: **NEVER** use this ruleset in production; it allows
// anyone to overwrite your entire database.

service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if true;
    }
  }
}

{
  // Allow read/write access to all users under any conditions
  // Warning: **NEVER** use this ruleset in production; it allows
  // anyone to overwrite your entire database.

  "rules": {
    ".read": true,
    ".write": true
  }
}
    

// Anyone can read or write to the bucket, even non-users of your app.
// Because it is shared with App Engine, this will also make
// files uploaded via App Engine public.
// Warning: This rule makes every file in your Cloud Storage bucket accessible to any user.
// Apply caution before using it in production, since it means anyone
// can overwrite all your files.

service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read, write;
    }
  }
}
    

service cloud.firestore {
  match /databases/{database}/documents {
    // Allow only authenticated content owners access
    match /some_collection/{document} {
      allow read, write: if request.auth != null && request.auth.uid == request.resource.data.author_uid
    }
  }
}
  

service cloud.firestore {
  match /databases/{database}/documents {
    // Allow public read access, but only content owners can write
    match /some_collection/{document} {
      allow read: if true
      allow write: if request.auth != null && request.auth.uid == request.resource.data.author_uid
    }
  }
}
  

{
  "rules": {
    "some_path": {
      "$uid": {
        // Allow only authenticated content owners access to their data
        ".read": "auth !== null && auth.uid === $uid",
        ".write": "auth !== null && auth.uid === $uid"
      }
    }
  }
}
    

{
  // Allow anyone to read data, but only authenticated content owners can
  // make changes to their data

  "rules": {
    "some_path/$uid": {
      ".read": true,
      // or ".read": "auth.uid !== null" for only authenticated users
      ".write": "auth.uid === $uid"
    }
  }
}
    

// Grants a user access to a node matching their user ID
service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/path/to/file.txt"
    match /user/{userId}/{allPaths=**} {
      allow read, write: if request.auth.uid == userId;
    }
  }
}

service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/path/to/file.txt"
    match /user/{userId}/{allPaths=**} {
      allow read;
      allow write: if request.auth.uid == userId;
    }
  }
}
  

Acceso para cualquier usuario autenticado

A veces, las reglas verifican que un usuario haya iniciado sesión, pero no restringen aún más el acceso según esa autenticación. Si una de sus reglas incluye auth != null , confirme que desea que cualquier usuario que haya iniciado sesión tenga acceso a los datos.

service cloud.firestore {
  match /databases/{database}/documents {
    match /some_collection/{document} {
      allow read, write: if request.auth.uid != null;
    }
  }
}

{
  "rules": {
    ".read": "auth.uid !== null",
    ".write": "auth.uid !== null"
  }
}

// Only authenticated users can read or write to the bucket
service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read, write: if request.auth != null;
    }
  }
}

service cloud.firestore {
  match /databases/{database}/documents {
    // Assign roles to all users and refine access based on user roles
    match /some_collection/{document} {
     allow read: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.role == "Reader"
     allow write: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.role == "Writer"

     // Note: Checking for roles in your database using `get` (as in the code
     // above) or `exists` carry standard charges for read operations.
    }
  }
}

// Give each user in your database a particular attribute
// and set it to true/false
// Then, use that attribute to grant access to subsets of data
// For example, an "admin" attribute set
// to "true" grants write access to data

service cloud.firestore {
  match /databases/{database}/documents {
    match /collection/{document} {
      allow write: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.admin == true;
      allow read: true;
    }
  }
}
  

service cloud.firestore {
  match /databases/{database}/documents {
    // Allow public read access, but only content owners can write
    match /some_collection/{document} {
      allow read: if true
      allow write: if request.auth.uid == request.resource.data.author_uid
    }
  }
}
  

{
  "rules": {
    "some_path": {
      "$uid": {
        // Allow only authenticated content owners access to their data
        ".read": "auth.uid === $uid",
        ".write": "auth.uid === $uid"
      }
    }
  }
}
    

{
  "rules": {
    "some_path/$uid": {
      ".write": "auth.uid === $uid",
      // Create a "public" subpath in your dataset
      "public": {
        ".read": true
        // or ".read": "auth.uid !== null"
      },
      // Create a "private" subpath in your dataset
      "private": {
        ".read": "auth.uid === $uid"
      }
    }
  }
}
    

{
  // Allow anyone to read data, but only authenticated content owners can
  // make changes to their data

  "rules": {
    "some_path/$uid": {
      ".read": true,
      // or ".read": "auth.uid !== null" for only authenticated users
      ".write": "auth.uid === $uid"
    }
  }
}
    

// Allow reads if the group ID in your token matches the file metadata's `owner` property
// Allow writes if the group ID is in the user's custom token
match /files/{groupId}/{fileName} {
  allow read: if resource.metadata.owner == request.auth.token.groupId;
  allow write: if request.auth.token.groupId == groupId;
}

// Grants a user access to a node matching their user ID
service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/path/to/file.txt"
    match /user/{userId}/{allPaths=**} {
      allow read, write: if request.auth.uid == userId;
    }
  }
}

service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/path/to/file.txt"
    match /user/{userId}/{allPaths=**} {
      allow read;
      allow write: if request.auth.uid == userId;
    }
  }
}
  

(Base de datos en tiempo real) Reglas heredadas incorrectamente

Las reglas de seguridad de bases de datos en tiempo real caen en cascada, con reglas en rutas principales más superficiales que anulan las reglas en nodos secundarios más profundos. Cuando escriba una regla en un nodo secundario, recuerde que solo puede otorgar privilegios adicionales. No puede refinar ni revocar el acceso a los datos en una ruta más profunda de su base de datos.

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

Acceso cerrado

Mientras desarrolla su aplicación, otro enfoque común es mantener sus datos bloqueados. Normalmente, esto significa que ha cerrado el acceso de lectura y escritura a todos los usuarios, de la siguiente manera:

// Deny read/write access to all users under any conditions
service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if false;
    }
  }
}

{
  "rules": {
    ".read": false,
    ".write": false
  }
}
    

// Access to files through Cloud Storage is completely disallowed.
// Files may still be accessible through App Engine or Google Cloud Storage APIs.

service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read, write: if false;
    }
  }
}

Los SDK de Firebase Admin y las funciones de nube aún pueden acceder a su base de datos. Utilice estas reglas cuando desee utilizar Cloud Firestore o Realtime Database como backend solo de servidor junto con el SDK de Firebase Admin. Si bien es seguro, debes probar que los clientes de tu aplicación puedan recuperar datos correctamente.

Obtenga más información sobre las reglas de seguridad de Cloud Firestore y cómo funcionan en Introducción a las reglas de seguridad de Cloud Firestore .

Pruebe sus reglas de seguridad de Cloud Firestore

Para verificar el comportamiento de su aplicación y verificar las configuraciones de sus reglas de seguridad de Cloud Firestore, use Firebase Emulator . Utilice el emulador de Cloud Firestore para ejecutar y automatizar pruebas unitarias en un entorno local antes de implementar cualquier cambio.

Para validar rápidamente las reglas de seguridad de Firebase en Firebase console, use el Simulador de reglas de Firebase .