Validación de datos

Puedes usar las reglas de seguridad de Firebase para escribir datos nuevos de forma condicional en función de los datos existentes en la base de datos o el bucket de almacenamiento. También puedes escribir reglas que apliquen validaciones de datos mediante la restricción de operaciones de escritura sobre la base de los datos nuevos que se escriben. Continúa leyendo para obtener más información sobre las reglas que usan los datos existentes a fin de crear condiciones de seguridad.

Selecciona un producto en cada sección para obtener más información sobre sus reglas de validación de datos.

Restricciones sobre datos nuevos

Cloud Firestore

Si deseas asegurarte de que no se cree un documento que contenga un campo específico, puedes incluir el campo en la condición allow. Por ejemplo, si deseas denegar la creación de cualquier documento que contenga el campo ranking, debes inhabilitarla en la condición create.

  service cloud.firestore {
    match /databases/{database}/documents {
      // Disallow
      match /cities/{city} {
        allow create: if !("ranking" in request.resource.data)
      }
    }
  }

Realtime Database

Si deseas asegurarte de que los datos que contienen ciertos valores no se agreguen a tu base de datos, deberías incluir esos valores en tus reglas e inhabilitarlos en las operaciones de escritura. Por ejemplo, si deseas denegar escrituras que contengan valores ranking, debes inhabilitar las escrituras respecto de cualquier documento con valores ranking.

  {
    "rules": {
      // Write is allowed for all paths
      ".write": true,
      // Allows writes only if new data doesn't include a `ranking` child value
      ".validate": "!newData.hasChild('ranking')
    }
  }

Cloud Storage

Si deseas asegurarte de que no se cree un archivo que contenga metadatos específicos, puedes incluir los metadatos en la condición allow. Por ejemplo, si deseas denegar la creación de cualquier archivo que contenga metadatos ranking, debes inhabilitarlos en la condición create.

  service firebase.storage {
    match /b/{bucket}/o {
      match /files/{allFiles=**} {
      // Disallow
        allow create: if !("ranking" in request.resource.metadata)
      }
    }
  }

Usa datos existentes en las reglas de seguridad de Firebase

Cloud Firestore

Muchas apps almacenan información de control de acceso como campos en documentos dentro de una base de datos. Las reglas de seguridad de Cloud Firestore pueden permitir o rechazar el acceso de forma dinámica según los datos del documento:

  service cloud.firestore {
    match /databases/{database}/documents {
      // Allow the user to read data if the document has the 'visibility'
      // field set to 'public'
      match /cities/{city} {
        allow read: if resource.data.visibility == 'public';
      }
    }
  }

La variable resource hace referencia al documento solicitado, y resource.data es un mapa de todos los campos y los valores almacenados en el documento. Para obtener más información sobre la variable resource, consulta la documentación de referencia.

Cuando escribas datos, te recomendamos comparar los datos entrantes con los existentes. Esto te permite realizar acciones como asegurarte de que un campo no haya cambiado, que un campo solo se haya incrementado en uno o que el valor nuevo corresponda a al menos una semana en el futuro. En este caso, si el conjunto de reglas permite la escritura pendiente, la variable request.resource contendrá el estado futuro del documento. Para las operaciones update en las que solo se modifica un subconjunto de los campos del documento, la variable request.resource contendrá el estado del documento pendiente después de la operación. Puedes verificar los valores de los campos de request.resource a fin de evitar actualizaciones de datos no deseadas o incoherentes. Para ello, usa este código:

   service cloud.firestore {
     match /databases/{database}/documents {
      // Make sure all cities have a positive population and
      // the name is not changed
      match /cities/{city} {
        allow update: if request.resource.data.population > 0
                      && request.resource.data.name == resource.data.name;
      }
    }
  }

Realtime Database

En Realtime Database, usa reglas .validate para aplicar estructuras de datos y validar el formato y el contenido de los datos. Las reglas ejecutan reglas .validate después de verificar que una regla .write otorga acceso.

Las reglas .validate no se transmiten en cascada. Si alguna regla de validación falla en alguna ruta principal o secundaria de la regla, se rechazará la operación de escritura completa. Además, las definiciones de validación solo verifican valores no nulos y, posteriormente, ignoran cualquier solicitud que borre datos.

Ten en cuenta las siguientes reglas .validate:

  {
    "rules": {
      // write is allowed for all paths
      ".write": true,
      "widget": {
        // a valid widget must have attributes "color" and "size"
        // allows deleting widgets (since .validate is not applied to delete rules)
        ".validate": "newData.hasChildren(['color', 'size'])",
        "size": {
          // the value of "size" must be a number between 0 and 99
          ".validate": "newData.isNumber() &&
                        newData.val() >= 0 &&
                        newData.val() <= 99"
        },
        "color": {
          // the value of "color" must exist as a key in our mythical
          // /valid_colors/ index
          ".validate": "root.child('valid_colors/' + newData.val()).exists()"
        }
      }
    }
  }

Las solicitudes de escritura a una base de datos con las reglas mencionadas anteriormente tendrían los siguientes resultados:

JavaScript
var ref = db.ref("/widget");

// PERMISSION_DENIED: does not have children color and size
ref.set('foo');

// PERMISSION DENIED: does not have child color
ref.set({size: 22});

// PERMISSION_DENIED: size is not a number
ref.set({ size: 'foo', color: 'red' });

// SUCCESS (assuming 'blue' appears in our colors list)
ref.set({ size: 21, color: 'blue'});

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child('size').set(99);
Objective‑C
Nota: Este producto de Firebase no está disponible en el destino de App Clips.
FIRDatabaseReference *ref = [[[FIRDatabase database] reference] child: @"widget"];

// PERMISSION_DENIED: does not have children color and size
[ref setValue: @"foo"];

// PERMISSION DENIED: does not have child color
[ref setValue: @{ @"size": @"foo" }];

// PERMISSION_DENIED: size is not a number
[ref setValue: @{ @"size": @"foo", @"color": @"red" }];

// SUCCESS (assuming 'blue' appears in our colors list)
[ref setValue: @{ @"size": @21, @"color": @"blue" }];

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
[[ref child:@"size"] setValue: @99];
Swift
Nota: Este producto de Firebase no está disponible en el destino de App Clips.
var ref = FIRDatabase.database().reference().child("widget")

// PERMISSION_DENIED: does not have children color and size
ref.setValue("foo")

// PERMISSION DENIED: does not have child color
ref.setValue(["size": "foo"])

// PERMISSION_DENIED: size is not a number
ref.setValue(["size": "foo", "color": "red"])

// SUCCESS (assuming 'blue' appears in our colors list)
ref.setValue(["size": 21, "color": "blue"])

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child("size").setValue(99);
Java
FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("widget");

// PERMISSION_DENIED: does not have children color and size
ref.setValue("foo");

// PERMISSION DENIED: does not have child color
ref.child("size").setValue(22);

// PERMISSION_DENIED: size is not a number
Map<String,Object> map = new HashMap<String, Object>();
map.put("size","foo");
map.put("color","red");
ref.setValue(map);

// SUCCESS (assuming 'blue' appears in our colors list)
map = new HashMap<String, Object>();
map.put("size", 21);
map.put("color","blue");
ref.setValue(map);

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child("size").setValue(99);
REST
# PERMISSION_DENIED: does not have children color and size
curl -X PUT -d 'foo' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# PERMISSION DENIED: does not have child color
curl -X PUT -d '{"size": 22}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# PERMISSION_DENIED: size is not a number
curl -X PUT -d '{"size": "foo", "color": "red"}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# SUCCESS (assuming 'blue' appears in our colors list)
curl -X PUT -d '{"size": 21, "color": "blue"}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# If the record already exists and has a color, this will
# succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
# will fail to validate
curl -X PUT -d '99' \
https://docs-examples.firebaseio.com/rest/securing-data/example/size.json

Cloud Storage

Al evaluar la aplicación de reglas, te recomendamos que también evalúes los metadatos del archivo que se va a subir, descargar, modificar o borrar. Esto te permite crear reglas complejas y potentes que ejecutan tareas como permitir que se suban archivos con ciertos tipos de contenido solamente o que solo se borren los archivos que superen cierto tamaño.

El objeto resource contiene pares clave-valor con metadatos de archivo que se muestran en un objeto de Cloud Storage. Estas propiedades se pueden inspeccionar en solicitudes read o write para garantizar la integridad de los datos. El objeto resource verifica los metadatos de los archivos existentes del bucket de Cloud Storage.

  service firebase.storage {
    match /b/{bucket}/o {
      match /images {
        match /{allImages=**} {
          // Allow reads if a custom 'visibility' field is set to 'public'
          allow read: if resource.metadata.visibility == 'public';
        }
      }
    }
  }

También puedes usar el objeto request.resource en solicitudes write (como cargas, actualizaciones de metadatos y eliminaciones). El objeto request.resource obtiene metadatos del archivo que se escribirá si se permite write.

Puedes usar estos dos valores a fin de evitar actualizaciones no deseadas o inconsistentes, o bien para aplicar las restricciones correspondientes, como las relativas al tipo o el tamaño de los archivos.

  service firebase.storage {
    match /b/{bucket}/o {
      match /images {
        // Cascade read to any image type at any path
        match /{allImages=**} {
          allow read;
        }

        // Allow write files to the path "images/*", subject to the constraints:
        // 1) File is less than 5MB
        // 2) Content type is an image
        // 3) Uploaded content type matches existing content type
        // 4) File name (stored in imageId wildcard variable) is less than 32 characters
        match /{imageId} {
          allow write: if request.resource.size < 5 * 1024 * 1024
                       && request.resource.contentType.matches('image/.*')
                       && request.resource.contentType == resource.contentType
                       && imageId.size() < 32
        }
      }
    }
  }

Puedes encontrar una lista completa de propiedades en el objeto resource en la documentación de referencia.