Implementa y administra las reglas de seguridad de Firebase

Firebase te proporciona varias herramientas para administrar tu Rules, cada una útil en casos particulares y cada una con la misma API de administración de reglas de seguridad de Firebase de backend.

No importa qué herramienta se utilice para invocarla, la API de administración realiza las siguientes acciones:

• Transfiere una fuente de reglas: un conjunto de reglas, generalmente un archivo de código que contiene sentencias Firebase Security Rules.
• Almacena la fuente transferida como un conjunto de reglas inmutable.
• Realiza un seguimiento de la implementación de cada conjunto de reglas de una versión. Los servicios habilitados para reglas de seguridad de Firebase buscan la versión de un proyecto a fin de evaluar cada solicitud de un recurso protegido.
• Proporciona la capacidad para ejecutar pruebas sintácticas y semánticas de un conjunto de reglas.

Usa la CLI de Firebase

Con la CLI de Firebase, puedes subir fuentes locales y, además, implementar versiones. Firebase Local Emulator Suite de la CLI te permite realizar pruebas locales completas de las fuentes.

El uso de CLI te permite mantener las reglas bajo control de versión con el código de la aplicación y, además, aplicar reglas como parte del proceso de implementación existente.

Genera un archivo de configuración

Cuando configuras tu proyecto de Firebase con Firebase CLI, creas un archivo de configuración .rules en el directorio de tu proyecto. Usa el siguiente comando para comenzar la configuración del proyecto de Firebase:

Cloud Firestore

// Set up Firestore in your project directory, creates a .rules file
firebase init firestore

Realtime Database

// Set up Realtime Database in your project directory, creates a .rules file
firebase init database

Cloud Storage

// Set up Storage in your project directory, creates a .rules file
firebase init storage

Edita y actualiza tus reglas

Edita la fuente de las reglas directamente en el archivo de configuración .rules.

Asegúrate de que las modificaciones que realices en Firebase CLI se reflejen en Firebase console, o de realizar actualizaciones de forma coherente con Firebase console o Firebase CLI. De lo contrario, es posible que reemplaces las actualizaciones realizadas en la consola de Firebase.

Nota: Cuando implementas reglas de seguridad con la CLI de Firebase, las reglas definidas en el directorio del proyecto reemplazan cualquier regla existente en la consola de Firebase. Por lo tanto, si defines o editas las reglas de seguridad con la consola de Firebase, recuerda actualizar las reglas definidas en el directorio del proyecto.

Prueba tus actualizaciones

Local Emulator Suite proporciona emuladores para todos los productos habilitados para las reglas de seguridad. El motor de reglas de seguridad por cada emulador realiza una evaluación sintáctica y semántica de las reglas, lo que supera la prueba sintáctica que ofrece la API de administración de reglas de seguridad.

Si trabajas con la CLI, Suite es una excelente herramienta para las pruebas de Firebase Security Rules. Usa Local Emulator Suite para probar tus actualizaciones de forma local y confirmar que el Rules de tu app exhibe el comportamiento que deseas.

Implementa tus actualizaciones

Una vez que hayas actualizado y probado tu Rules, implementa las fuentes en producción.

Para Cloud Firestore Security Rules, asocia los archivos .rules con tus bases de datos predeterminadas y adicionales con nombre revisando y actualizando tu archivo firebase.json.

Usa los siguientes comandos para implementar de manera selectiva solo tus Rules o hacerlo como parte del proceso de implementación normal.

Cloud Firestore

// Deploy rules for all databases configured in your firebase.json
firebase deploy --only firestore:rules

// Deploy rules for the specified database configured in your firebase.json
firebase deploy --only firestore:<databaseId>

Realtime Database

// Deploy your .rules file
firebase deploy --only database

Cloud Storage

// Deploy your .rules file
firebase deploy --only storage

Usa Firebase console

Nota: La consola de Firebase admite la implementación de Cloud Firestore Security Rules en la base de datos predeterminada de tu proyecto. Las actualizaciones futuras te permitirán implementar Rules en bases de datos adicionales de tu proyecto. Puedes usar la CLI de Firebase para trabajar con Rules en tus proyectos de varias bases de datos.

También puedes editar fuentes de Rules y, luego, implementarlas como versiones desde la consola de Firebase. Las pruebas sintácticas se realizan mientras haces modificaciones en la IU de Firebase console, y las pruebas semánticas están disponibles mediante la Zona de pruebas de Rules.

Edita y actualiza tus reglas

1. Abre la consola de Firebase y selecciona tu proyecto.
2. Luego, selecciona Realtime Database, Cloud Firestore o Storage en la navegación del producto y haz clic en Rules para navegar al editor de Rules.
3. Edita tus reglas directamente en el editor.

Nota: Cuando implementas reglas de seguridad con la CLI de Firebase, las reglas definidas en el directorio del proyecto reemplazan cualquier regla existente en la consola de Firebase. Por lo tanto, si defines o editas las reglas de seguridad con la consola de Firebase, recuerda actualizar las reglas definidas en el directorio del proyecto.

Prueba tus actualizaciones

Además de probar la sintaxis en la IU del editor, puedes probar el comportamiento de Rules semánticas mediante la base de datos de tu proyecto y los recursos de almacenamiento, directamente en la consola de Firebase, con el Campo de pruebas de Rules. Abre la pantalla Zona de pruebas de reglas en el editor de Rules, modifica la configuración y haz clic en Ejecutar. Busca el mensaje de confirmación en la parte superior del editor.

Implementa tus actualizaciones

Una vez que estés satisfecho con las actualizaciones, haz clic en Publicar.

Usa el SDK de Admin

Nota: Actualmente, Firebase Admin SDK admite la implementación de Cloud Firestore Security Rules en la base de datos predeterminada de tu proyecto. Las actualizaciones futuras te permitirán implementar Rules en bases de datos adicionales de tu proyecto. Puedes usar la CLI de Firebase para trabajar con Rules en tus proyectos de varias bases de datos.

Puedes usar Admin SDK para los conjuntos de reglas de Node.js. Con este acceso programático, puedes hacer lo siguiente:

• Implementa herramientas personalizadas, secuencias de comandos, paneles y canalizaciones de CI/CD para administrar las reglas.
• Administra reglas con más facilidad en varios proyectos de Firebase.

Cuando se actualizan las reglas de manera programática, es muy importante evitar los cambios no deseados en el control de acceso de la app. Escribe el código de Admin SDK con la seguridad en mente, especialmente cuando actualices o implementes reglas.

Otro punto importante que se debe tener en cuenta es que las versiones de Firebase Security Rules tardan varios minutos en propagarse por completo. Cuando uses Admin SDK para implementar reglas, asegúrate de evitar las condiciones de carrera en las que la app dependa de inmediato de reglas cuya implementación aún no se haya completado. Si tu caso de uso requiere actualizaciones frecuentes para las reglas de control de acceso, considera las soluciones que usan Cloud Firestore, que está diseñado para reducir las condiciones de carrera a pesar de las actualizaciones frecuentes.

Nota: Aunque ahora es posible realizar pruebas de unidades en las reglas con los emuladores locales de Cloud Firestore y Realtime Database, las pruebas no están disponibles a través de este SDK. Si deseas asegurarte de que las reglas se prueben antes de la implementación, no te recomendamos que las actualices mediante Admin SDK.

También ten en cuenta estos límites:

• El tamaño de las reglas debe ser menor que 256 KiB de texto codificado en UTF-8 cuando se serializan.
• Un proyecto puede tener un máximo de 2,500 conjuntos de reglas implementados. Una vez que se alcanza este límite, debes borrar algunos conjuntos de reglas antiguos antes de crear otros nuevos.

Crea e implementa conjuntos de reglas de Cloud Storage o Cloud Firestore

Un flujo de trabajo típico para administrar reglas de seguridad con Admin SDK podría incluir los tres pasos discretos siguientes:

1. Crear una fuente de archivo de reglas (opcional)
2. Crear un conjunto de reglas
3. Lanzar o implementar el nuevo conjunto de reglas

El SDK proporciona un método para combinar estos pasos en una sola llamada a la API para las reglas de seguridad de Cloud Storage y Cloud Firestore. Por ejemplo:

    const source = `service cloud.firestore {
      match /databases/{database}/documents {
        match /carts/{cartID} {
          allow create: if request.auth != null && request.auth.uid == request.resource.data.ownerUID;
          allow read, update, delete: if request.auth != null && request.auth.uid == resource.data.ownerUID;
        }
      }
    }`;
    // Alternatively, load rules from a file
    // const fs = require('fs');
    // const source = fs.readFileSync('path/to/firestore.rules', 'utf8');

    await admin.securityRules().releaseFirestoreRulesetFromSource(source);

Este mismo patrón funciona para las reglas de Cloud Storage con releaseFirestoreRulesetFromSource().

Como alternativa, puedes crear el archivo de reglas como un objeto en la memoria, crear el conjunto de reglas y, luego, implementar el conjunto de reglas por separado para controlar mejor estos eventos. Por ejemplo:

    const rf = admin.securityRules().createRulesFileFromSource('firestore.rules', source);
    const rs = await admin.securityRules().createRuleset(rf);
    await admin.securityRules().releaseFirestoreRuleset(rs);

Actualiza los conjuntos de reglas de Realtime Database

Para actualizar los conjuntos de reglas de Realtime Database con Admin SDK, usa los métodos getRules() y setRules() de admin.database. Puedes recuperar conjuntos de reglas en formato JSON o una string con comentarios incluidos.

Usa el siguiente código para actualizar un conjunto de reglas:

    const source = `{
      "rules": {
        "scores": {
          ".indexOn": "score",
          "$uid": {
            ".read": "$uid == auth.uid",
            ".write": "$uid == auth.uid"
          }
        }
      }
    }`;
    await admin.database().setRules(source);

Administra conjuntos de reglas

Para ayudar a administrar conjuntos de reglas grandes, Admin SDK te permite enumerar todas las reglas existentes con admin.securityRules().listRulesetMetadata. Por ejemplo:

    const allRulesets = [];
    let pageToken = null;
    while (true) {
      const result = await admin.securityRules().listRulesetMetadata(pageToken: pageToken);
      allRulesets.push(...result.rulesets);
      pageToken = result.nextPageToken;
      if (!pageToken) {
        break;
      }
    }

Para implementaciones muy grandes que, con el tiempo, alcanzan el límite de 2,500 conjuntos de reglas, puedes crear una lógica a fin de borrar las reglas más antiguas en un ciclo de tiempo fijo. Usa el siguiente ejemplo para borrar todos los conjuntos de reglas implementados durante más de 30 días:

    const thirtyDays = new Date(Date.now() - THIRTY_DAYS_IN_MILLIS);
    const promises = [];
    allRulesets.forEach((rs) => {
      if (new Date(rs.createTime) < thirtyDays) {
        promises.push(admin.securityRules().deleteRuleset(rs.name));
      }
    });
    await Promise.all(promises);
    console.log(`Deleted ${promises.length} rulesets.`);

Usa la API de REST

Las herramientas descritas anteriormente son adecuadas para varios flujos de trabajo, incluida la administración de Firebase Security Rules para varias bases de datos de Cloud Firestore en tu proyecto, pero te recomendamos que administres y también implementes Firebase Security Rules con la API de administración. La API de administración te brinda la mayor flexibilidad.

Nota: En esta sección, se abordan casos de uso de administración básica similares a los que se mostraron anteriormente. Para obtener más casos de uso y ejemplos disponibles con esta API, consulta la documentación de referencia completa de la API de REST para la administración de reglas.

También ten en cuenta estos límites:

• El tamaño de las reglas debe ser menor que 256 KiB de texto codificado en UTF-8 cuando se serializan.
• Un proyecto puede tener un máximo de 2,500 conjuntos de reglas implementados. Una vez que se alcanza este límite, debes borrar algunos conjuntos de reglas antiguos antes de crear otros nuevos.

Crea e implementa conjuntos de reglas de Cloud Firestore o Cloud Storage con REST

En los ejemplos de esta sección, se usa Rules de Firestore, aunque también se aplican a Rules de Cloud Storage.

En los ejemplos también se usa cURL para realizar llamadas a la API. Se omiten los pasos para configurar y pasar tokens de autenticación. Puedes experimentar con esta API a través del Explorador de API integrado en la documentación de referencia.

Los pasos típicos para crear y, luego, implementar un conjunto de reglas mediante la API de administración son los siguientes:

1. Crea fuentes de archivos de reglas
2. Crear un conjunto de reglas
3. Lanzar (implementar) el nuevo conjunto de reglas

Crea una fuente

Supongamos que estás trabajando en tu proyecto de Firebase secure_commerce y deseas implementar un Rules Cloud Firestore bloqueado en una base de datos de tu proyecto llamada east_store.

Puedes implementar estas reglas en un archivo firestore.rules.

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

Crear un conjunto de reglas

Ahora, genera una huella digital codificada en Base64 para este archivo. Puedes usar la fuente en este archivo para propagar la carga útil necesaria a fin de crear un conjunto de reglas con la llamada de REST projects.rulesets.create. Aquí, usa el comando cat para insertar el contenido de firestore.rules en la carga útil de REST.

Para el seguimiento, para asociar esto con tu base de datos east_store, establece attachment_point en east_store.

curl -X POST -d '{
  "source": {
    "files": [
      {
        "content": "' $(cat storage.rules) '",
        "name": "firestore.rules",
        "fingerprint": <sha fingerprint>
      },
    "attachment_point": "firestore.googleapis.com/databases/east_store"
    ]
  }
}' 'https://firebaserules.googleapis.com/v1/projects/secure_commerce/rulesets'

La API muestra una respuesta de validación y un nombre de conjunto de reglas, por ejemplo, projects/secure_commerce/rulesets/uuid123.

Lanza (implementa) un conjunto de reglas

Si el conjunto de reglas es válido, el último paso es implementar el nuevo conjunto de reglas en una versión con nombre.

curl -X POST -d '{
  "name": "projects/secure_commerce/releases/cloud.firestore/east_store"  ,
  "rulesetName": "projects/secure_commerce/rulesets/uuid123"
}' 'https://firebaserules.googleapis.com/v1/projects/secure_commerce/releases'

Nota: Para la versión de la base de datos (predeterminada), la ruta de acceso projects//releases/cloud.firestore/(default) es equivalente a projects//releases/cloud.firestore.

Ten en cuenta que las versiones de Firebase Security Rules tardan varios minutos en propagarse por completo. Cuando uses la API de REST de administración para realizar implementaciones, asegúrate de evitar condiciones de carrera en las que la app dependa de inmediato de reglas cuya implementación aún no se haya completado.

Actualiza los conjuntos de reglas de Realtime Database con REST

Realtime Database proporciona su propia interfaz REST para administrar Rules. Consulta Administra Realtime Database Rules de Firebase mediante REST.

Administra conjuntos de reglas con REST

A fin de ayudar a administrar grandes implementaciones de reglas, además de un método REST para crear conjuntos de reglas y versiones, la API de administración proporciona métodos con el fin de realizar las siguientes acciones:

• enumerar, obtener y borrar conjuntos de reglas
• enumerar, obtener y borrar versiones de reglas

Para implementaciones muy grandes que, con el tiempo, alcanzan el límite de 2,500 conjuntos de reglas, puedes crear una lógica a fin de borrar las reglas más antiguas en un ciclo de tiempo fijo. Por ejemplo, para borrar todos los conjuntos de reglas implementados durante más de 30 días, puedes llamar al método projects.rulesets.list, analizar la lista JSON de los objetos Ruleset en sus claves createTime y, luego, llamar a project.rulesets.delete en los conjuntos de reglas correspondientes por ruleset_id.

Prueba tus actualizaciones con REST

Por último, la API de administración te permite ejecutar pruebas sintácticas y semánticas en los recursos de Cloud Firestore y Cloud Storage de tus proyectos de producción.

Nota: Las pruebas que se ejecutan con la API de REST usan bases de datos de producción, buckets de almacenamiento y recursos relacionados. Esas pruebas pueden generar cargos de uso. Te recomendamos que uses Firebase Local Emulator Suite para realizar pruebas de Firebase Security Rules, ya que puedes ejecutar pruebas en recursos sin conexión y que no son de producción sin cargos. Consulta nuestra guía sobre cómo probar Firebase Security Rules con Local Emulator Suite.

Las pruebas con este componente de la API consisten en realizar lo siguiente:

1. Definir un objeto JSON TestSuite para representar un conjunto de objetos TestCase
2. Enviar el TestSuite
3. Analizar los objetos TestResult que se muestran

Definamos un objeto TestSuite con un único TestCase en un archivo testcase.json. En este ejemplo, pasamos la fuente del lenguaje Rules intercalada con la carga útil de REST, junto con el conjunto de pruebas que se ejecutarán en esas reglas. Especificamos una expectativa de evaluación de reglas y la solicitud de cliente en la que se probará el conjunto de reglas. También puedes especificar qué tan completo quieres que sea el informe de pruebas con el valor “FULL” para indicar que se deben incluir los resultados de todas las expresiones de lenguaje de Rules, incluidas aquellas que no coincidan con la solicitud.

 {
  "source":
  {
    "files":
    [
      {
        "name": "firestore.rules",
        "content": "service cloud.firestore {
          match /databases/{database}/documents {
            match /users/{userId}{
              allow read: if (request.auth.uid == userId);
            }
            function doc(subpath) {
              return get(/databases/$(database)/documents/$(subpath)).data;
            }
            function isAccountOwner(accountId) {
              return request.auth.uid == accountId 
                  || doc(/users/$(request.auth.uid)).accountId == accountId;
            }
            match /licenses/{accountId} {
              allow read: if isAccountOwner(accountId);
            }
          }
        }"
      }
    ]
  },
  "testSuite":
  {
    "testCases":
    [
      {
        "expectation": "ALLOW",
        "request": {
           "auth": {"uid": "123"},
           "path": "/databases/(default)/documents/licenses/abcd",
           "method": "get"},
        "functionMocks": [
            {
            "function": "get",
            "args": [{"exact_value": "/databases/(default)/documents/users/123"}],
            "result": {"value": {"data": {"accountId": "abcd"}}}
            }
          ]
      }
    ]
  }
}

Luego, podemos enviar este TestSuite para que se evalúe con el método projects.test.

curl -X POST -d '{
    ' $(cat testcase.json) '
}' 'https://firebaserules.googleapis.com/v1/projects/secure_commerce/rulesets/uuid123:test'

El TestReport que se muestra (que contiene el estado SUCCESS/FAILURE de la prueba, las listas de mensajes de depuración, las listas de expresiones de reglas visitadas y sus informes de evaluación) confirmaría con el estado SUCCESS que el acceso está permitido de forma correcta.

Administra permisos para Cloud Storage Security Rules entre servicios

Si creas Cloud Storage Security Rules que usan contenido de documentos de Cloud Firestore para evaluar las condiciones de seguridad, se te pedirá que habilites permisos en la consola de Firebase o en la CLI de Firebase para conectar los dos productos.

Si decides inhabilitar esa seguridad entre servicios, haz lo siguiente:

1. Antes de inhabilitar la función, edita las reglas y quita todas las declaraciones que usan funciones de Rules para acceder a Cloud Firestore. De lo contrario, después de que se inhabilite la función, las evaluaciones de Rules provocarán que las solicitudes de Storage fallen.

2. Usa la página de IAM en la consola de Google Cloud a fin de borrar el rol “Agente de servicio de Firestore para las reglas de Firebase” mediante la guía de Cloud para revocar roles.

   Nota: En la página de IAM, marca la casilla “Incluir asignaciones de roles proporcionados por Google” para ver todos los roles.
   Nota: En la página de IAM, encontrarás la cuenta de servicio de Firebase Storage, con el ID que termina en @gcp-sa-firebasestorage.iam.gserviceaccount.com. Si las reglas entre servicios están habilitadas, verás el rol “Agente de servicio de Firestore para las reglas de Firebase” .

Se te solicitará que vuelvas a habilitar la función la próxima vez que guardes reglas entre servicios desde la CLI de Firebase o la consola de Firebase.