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

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

Esta guía describe la sintaxis básica y la estructura de las reglas de seguridad de Cloud Storage para crear conjuntos de reglas completos.

Declaración de servicio y base de datos

Las reglas de seguridad de Firebase para Cloud Storage siempre comienzan con la siguiente declaración:

service firebase.storage {
    // ...
}

El service firebase.storage declaración alcances a las normas almacenamiento en la nube, la prevención de conflictos entre la nube de almacenamiento reglas y normas de seguridad para otros productos como la nube Firestore.

Reglas básicas de lectura / escritura

Reglas básicas consisten en un match declaración identificando segmentos de Cloud Storage, una declaración partido especificar un nombre de archivo y una allow la expresión detallando cuando se permite la lectura de los datos especificados. allow expresiones especifican los métodos de acceso (por ejemplo, leer, escribir) que participan, y condiciones en que cualquiera tiene acceso o no acceso.

En su conjunto de reglas por defecto, el primer match instrucción utiliza un {bucket} expresión comodín para indicar las reglas se aplican a todos los cubos en su proyecto. Discutiremos más la idea de coincidencias de comodines 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 declaraciones coincidentes apuntan a archivos. Una declaración partido puede apuntar a un archivo específico, como en el match /images/profilePhoto.png .

Coincidir con comodines

En additiont a señalar a un solo archivo, las reglas pueden utilizar comodines para que apunte a cualquier archivo con un prefijo de cadena indicado en su nombre, incluyendo barras, como en el match /images/{imageId} .

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

Una variable comodín pueden ser referenciadas desde dentro del match para proporcionar el nombre del archivo o la autorización de ruta:

// 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 los archivos, 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 empiezan por los /images/ madre. Reglas de seguridad de base de fuego sólo se aplican en el nombre del archivo coincide, por lo que los controles de acceso definidos en las /images/ madre no se aplican a la /mp3s/ madre. 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 match declaraciones, el camino del interior match declaración siempre se agregará a la ruta del exterior match comunicado. Por tanto, los dos conjuntos de reglas siguientes 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 comodines que las cadenas de partido y volver al final de un nombre de archivo, un comodín segmento múltiple pueden asignarse para la coincidencia más compleja mediante la adición de =** al nombre 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 hay varias reglas se ajustan a un archivo, el resultado es el OR de los resultados de todas las evaluaciones de las reglas. Es decir, si cualquier regla que el archivo coincide dé como resultado true , el resultado es true .

En las normas anteriores, las "imágenes / profilePhoto.png" archivo se puede leer si alguna condition o other_condition como resultado true, mientras que el archivo "images / usuarios / usuarios: 12345 / profilePhoto.png" sólo está sujeta al resultado de other_condition .

Las reglas de seguridad de Cloud Storage no se transmiten 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 fichero como /images/profilePics/profile.png, pero no /images/badge.png. Uso /images/{imagePrefixorFilename=**} lugar.

Los comodines recursivos deben ir 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=**} partidos nombres de archivo y /images/profilePics/profile.png /images/badge.png.

Debe optar en la versión 2 mediante la adición de 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 lugar 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 desglosar read y write en las operaciones más granulares. Por ejemplo, es posible que su aplicación desee aplicar condiciones diferentes en la creación de archivos que en la eliminación de archivos.

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

Una write regla 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 document 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 nonexistent files
      allow create: if <condition>;

      // Applies to updates to 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 para que coincida con más de un match comunicado. En el caso en que múltiples allow expresiones coinciden con una petición, el acceso está permitido si cualquiera de las condiciones es true :

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, todas las lecturas y escrituras en archivos con la cadena /images/ en cualquier lugar de su nombre no será permitido porque la segunda regla es siempre true , a pesar de que la primera regla es siempre 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 coinciden 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 se rechaza la petición siguiente debido a que el conjunto de resultados puede incluir archivos donde contentType no está image/png :

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

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

Las reglas de las reglas de seguridad de almacenamiento en la nube evalúan cada consulta en función de su resultado potencial y fallan en la solicitud si pueden 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:

  • Aprender el siguiente concepto importante de la lengua en reglas dinámicas condiciones , que permita que su autorización de usuario consultar las reglas, comparar los datos existentes y entrantes, validar los datos entrantes, y mucho más.

  • Revisar los casos de uso típicos de seguridad y las definiciones Firebase reglas de seguridad que abordarlos .

Puedes explorar casos de uso de reglas de seguridad de Firebase específicos de Cloud Storage: