Check out what’s new from Firebase at Google I/O 2022. Learn more

Aprenda la sintaxis central de las reglas de seguridad de Firebase para el lenguaje de almacenamiento en la nube

Las reglas de seguridad de Firebase para Cloud Storage le permiten controlar el acceso a los objetos almacenados en depósitos de Cloud Storage. La sintaxis de reglas flexibles le permite crear reglas para controlar cualquier operación, desde todas las escrituras en su depósito de Cloud Storage hasta operaciones en un archivo específico.

Esta guía describe la sintaxis y la estructura básicas de las reglas de seguridad de almacenamiento en la nube para crear conjuntos de reglas completos.

Declaración de servicios y bases de datos

Las reglas de seguridad de Firebase para almacenamiento en la nube siempre comienzan con la siguiente declaración:

service firebase.storage {
    // ...
}

La declaración del service firebase.storage las reglas a Cloud Storage, lo que evita conflictos entre las reglas de seguridad de Cloud Storage y las reglas de otros productos, como Cloud Firestore.

Reglas básicas de lectura/escritura

Las reglas básicas consisten en una declaración de match que identifica los depósitos de Cloud Storage, una declaración de coincidencia que especifica un nombre de archivo y una expresión de allow detalla cuándo se permite leer los datos especificados. Las expresiones allow especifican los métodos de acceso (por ejemplo, lectura, escritura) involucrados y las condiciones bajo las cuales se permite o deniega el acceso.

En su conjunto de reglas predeterminado, la declaración de la primera match usa una expresión comodín {bucket} para indicar que las reglas se aplican a todos los depósitos en su proyecto. Hablaremos más sobre la idea de las coincidencias comodín en la siguiente sección.

service firebase.storage {
  // The {bucket} wildcard indicates we match files in all Cloud Storage buckets
  match /b/{bucket}/o {
    // Match filename
    match /filename {
      allow read: if <condition>;
      allow write: if <condition>;
    }
  }
}

Todas las sentencias de coincidencia apuntan a archivos. Una declaración de coincidencia puede apuntar a un archivo específico, como en match /images/profilePhoto.png .

Igualar comodines

Además de apuntar a un solo archivo, las reglas pueden usar comodines para apuntar a cualquier archivo con un prefijo de cadena determinado en su nombre, incluidas las barras, como en match /images/{imageId} .

En el ejemplo anterior, la declaración de coincidencia usa la sintaxis de comodín {imageId} . Esto significa que la regla se aplica a cualquier archivo con /images/ al comienzo de su nombre, como /images/profilePhoto.png o /images/croppedProfilePhoto.png . Cuando se evalúan las expresiones de allow en la declaración de coincidencia, la variable imageId se resolverá en el nombre de archivo de la imagen, como profilePhoto.png o croppedProfilePhoto.png .

Se puede hacer referencia a una variable comodín desde dentro de la match para proporcionar autorización de ruta o nombre de archivo:

// Another way to restrict the name of a file
match /images/{imageId} {
  allow read: if imageId == "profilePhoto.png";
}

datos jerárquicos

Como dijimos antes, no existe una estructura jerárquica dentro de un depósito de Cloud Storage. Pero al usar una convención de nomenclatura de archivos, a menudo una que incluye barras en los nombres de archivo, podemos imitar una estructura que parece una serie anidada de directorios y subdirectorios. Es importante comprender cómo interactúan las reglas de seguridad de Firebase con estos nombres de archivo.

Considere la situación de un conjunto de archivos con nombres que comienzan con la raíz /images/ . Las reglas de seguridad de Firebase se aplican solo en el nombre de archivo coincidente, por lo que los controles de acceso definidos en la raíz /images/ no se aplican a la raíz /mp3s/ . En su lugar, escriba reglas explícitas que coincidan con diferentes patrones de nombre de archivo:

service firebase.storage {
  match /b/{bucket}/o {
    match /images/{imageId} {
      allow read, write: if <condition>;
    }

    // Explicitly define rules for the 'mp3s' pattern
    match /mp3s/{mp3Id} {
      allow read, write: if <condition>;
    }
  }
}

Al anidar declaraciones de match , la ruta de la declaración de match interna siempre se agrega a la ruta de la declaración de match externa. Por lo tanto, los siguientes dos conjuntos de reglas son equivalentes:

service firebase.storage {
  match /b/{bucket}/o {
    match /images {
      // Exact match for "images/profilePhoto.png"
      match /profilePhoto.png {
        allow write: if <condition>;
      }
    }
  }
}
service firebase.storage {
  match /b/{bucket}/o {
    // Exact match for "images/profilePhoto.png"
    match /images/profilePhoto.png {
      allow write: if <condition>;
      }
  }
}

Comodines de coincidencia recursiva

Además de los comodines que coinciden y devuelven cadenas al final de un nombre de archivo, se puede declarar un comodín de varios segmentos para una coincidencia más compleja agregando =** al nombre del comodín, como {path=**} :

// Partial match for files that start with "images"
match /images {

  // Exact match for "images/**"
  // e.g. images/users/user:12345/profilePhoto.png is matched
  // images/profilePhoto.png is also matched!
  match /{allImages=**} {
    // This rule matches one or more path segments (**)
    // allImages is a path that contains all segments matched
    allow read: if <other_condition>;
  }
}

Si varias reglas coinciden con un archivo, el resultado es el OR del resultado de todas las evaluaciones de reglas. Es decir, si alguna regla con la que coincida el archivo se evalúa como true , el resultado es true .

En las reglas anteriores, el archivo "images/profilePhoto.png" se puede leer si la condition u other_condition se evalúa como verdadera, mientras que el archivo "images/users/user:12345/profilePhoto.png" solo está sujeto al resultado de other_condition . .

Las reglas de seguridad de Cloud Storage no se aplican en cascada y las reglas solo se evalúan cuando la ruta de la solicitud coincide con una ruta con las reglas especificadas.

Versión 1

Las reglas de seguridad de Firebase usan la versión 1 de forma predeterminada. En la versión 1, los comodines recursivos coinciden con uno o más elementos de nombre de archivo, no con cero o más elementos. Por lo tanto, match /images/{filenamePrefixWildcard}/{imageFilename=**} coincide con un nombre de archivo como /images/profilePics/profile.png, pero no /images/badge.png. Utilice /images/{imagePrefixorFilename=**} en su lugar.

Los comodines recursivos deben aparecer al final de una declaración de coincidencia.

Le recomendamos que utilice la versión 2 por sus funciones más potentes.

Versión 2

En la versión 2 de las reglas de seguridad de Firebase, los comodines recursivos coinciden con cero o más elementos de ruta. Por lo tanto, /images/{filenamePrefixWildcard}/{imageFilename=**} coincide con los nombres de archivo /images/profilePics/profile.png y /images/badge.png.

Debe optar por la versión 2 agregando rules_version = '2'; en la parte superior de sus reglas de seguridad:

rules_version = '2';
service cloud.storage {
  match /b/{bucket}/o {
   ...
 }
}

Puede tener como máximo un comodín recursivo por declaración de coincidencia, pero en la versión 2, puede colocar este comodín en cualquier parte de la declaración de coincidencia. Por ejemplo:

rules_version = '2';
service firebase.storage {
 match /b/{bucket}/o {
   // Matches any file in a songs "subdirectory" under the
   // top level of your Cloud Storage bucket.
   match /{prefixSegment=**}/songs/{mp3filenames} {
     allow read, write: if <condition>;
   }
  }
}

Operaciones granulares

En algunas situaciones, es útil dividir la read y write en operaciones más granulares. Por ejemplo, es posible que su aplicación quiera aplicar condiciones diferentes en la creación de archivos que en la eliminación de archivos.

Una operación de read se puede dividir en get y list .

Una regla de write se puede dividir en create , update y delete :

service firebase.storage {
  match /b/{bucket}/o {
    // A read rule can be divided into read and list rules
    match /images/{imageId} {
      // Applies to single file read requests
      allow get: if <condition>;
      // Applies to list and listAll requests (Rules Version 2)
      allow list: if <condition>;

    // A write rule can be divided into create, update, and delete rules
    match /images/{imageId} {
      // Applies to writes to file contents
      allow create: if <condition>;

      // Applies to updates to (pre-existing) file metadata
      allow update: if <condition>;

      // Applies to delete operations
      allow delete: if <condition>;
    }
  }
 }
}

Declaraciones de coincidencia superpuestas

Es posible que un nombre de archivo coincida con más de una declaración de match . En el caso de que varias expresiones de allow coincidan con una solicitud, se permite el acceso si se true alguna de las condiciones:

service firebase.storage {
  match b/{bucket}/o {
    // Matches any filename containing string '/images/'.
    match /images/{imageId} {
      allow read, write: if false;
    }

    // Matches all filenames containing string `/images/`
    match /images/{imageId=**} {
      allow read, write: if true;
    }
  }
}

En el ejemplo anterior, se permitirán todas las lecturas y escrituras en archivos con la cadena /images/ en cualquier parte de su nombre de archivo porque la segunda regla siempre es true , aunque la primera regla siempre es false .

Las reglas no son filtros

Una vez que asegure sus datos y comience a realizar operaciones con archivos, tenga en cuenta que las reglas de seguridad no son filtros. No puede realizar operaciones en un conjunto de archivos que coincidan con un patrón de nombre de archivo y esperar que Cloud Storage acceda solo a los archivos a los que el cliente actual tiene permiso para acceder.

Por ejemplo, tome la siguiente regla de seguridad:

service firebase.storage {
  match /b/{bucket}/o {
    // Allow the client to read files with contentType 'image/png'
    match /aFileNamePrefix/{aFileName} {
      allow read: if resource.contentType == 'image/png';
    }
  }
}

Denegado : esta regla rechaza la siguiente solicitud porque el conjunto de resultados puede incluir archivos donde contentType no es image/png :

Web
filesRef = storage.ref().child("aFilenamePrefix");

filesRef.listAll()
    .then(function(result) {
      console.log("Success: ", result.items);
    })
});

Las reglas en las reglas de seguridad de Cloud Storage evalúan cada consulta contra su resultado potencial y fallan la solicitud si puede devolver un archivo que el cliente no tiene permiso para leer. Las solicitudes de acceso deben seguir las restricciones establecidas por sus reglas.

Próximos pasos

Puede profundizar su comprensión de las reglas de seguridad de Firebase para el almacenamiento en la nube:

Puede explorar los casos de uso de las reglas de seguridad de Firebase específicos de Cloud Storage: