---
title: "Reglas de Firebase Storage: lo que logré saltar"
description: "Reglas de Firebase Storage en el emulador. Las de propietario aguantaron, pero una URL de descarga abrió el archivo a un invitado, y corregirlas no la cerró."
url: "https://madsalt.tech/es/blog/firebase-storage-rules/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/es/about/"
language: "es"
published: 2026-11-05
---

# Reglas de Firebase Storage: lo que logré saltar

En resumen

Una regla solo para el propietario en `users/{uid}/...` impidió que otros usuarios leyeran, listaran y escribieran. No impidió que un invitado con la URL de descarga del archivo lo leyera: esa petición devolvió `200`, y siguió devolviéndolo después de corregir las reglas. Una comprobación de `contentType` aceptó un script HTML subido como `image/png`. Y una comprobación de tamaño en `write` impidió que los usuarios borraran sus propios archivos. Reemplazar el archivo cambió el token y cerró el enlace antiguo.

Las reglas de Storage se parecen a las [reglas de Firestore](https://madsalt.tech/es/blog/firebase-security-rules-examples/), y la mayoría de las guías se quedan en "comprueba el uid en la ruta". Subí archivos de relleno con nombres como pasaportes y facturas para ver qué deja abierto esa comprobación.

**Cómo probé.** Firebase Local Emulator Suite de Firebase CLI 15.34.2, el 3 de noviembre de 2026, con los emuladores de Storage y Auth. Llamé a la API REST de Firebase Storage con tokens de un invitado, un usuario anónimo, los usuarios A y B, y un desconocido que solo se había registrado. Los archivos eran unos pocos bytes de datos de relleno, más otros mayores para las pruebas de tamaño.

## ¿Qué dejan pasar las reglas habituales de Storage?

| Regla                      | Petición                                   | Resultado         |
| -------------------------- | ------------------------------------------ | ----------------- |
| `if true` (modo de prueba) | Un invitado lista el bucket                | `200`, 4 archivos |
| `if true` (modo de prueba) | Un invitado sube un archivo HTML           | `200`             |
| `request.auth != null`     | Un usuario anónimo lee el archivo de B     | `200`             |
| `request.auth != null`     | Un desconocido lista el bucket             | `200`, 4 archivos |
| `request.auth != null`     | Un desconocido sobrescribe el archivo de B | `200`             |
| `request.auth != null`     | Un desconocido borra el archivo de A       | `204`             |

La de solo-con-sesión es la que hay que vigilar. Un invitado recibe `403`, así que pasa una mirada rápida, y luego cualquiera con una cuenta puede listar todas las rutas y reemplazar un pasaporte por cualquier cosa. La lista además le entrega el nombre de cada archivo, que aquí contiene el uid del propietario.

## ¿Protege el archivo una regla solo para el propietario?

Frente a otros usuarios, sí:

```
match /users/{uid}/{file=**} {
  allow read, write: if request.auth != null && request.auth.uid == uid;
}
```

| Petición                        | Resultado        |
| ------------------------------- | ---------------- |
| Un invitado lee el archivo de B | `403`            |
| A lee su propio archivo         | `200`            |
| A lee el archivo de B           | `403`            |
| A lista su propia carpeta       | `200`, 1 archivo |
| A lista la carpeta de B         | `403`            |
| A lista todo el bucket          | `403`            |
| A sobrescribe el archivo de B   | `403`            |

Eso es todo lo que prueba la mayoría de los tutoriales. Las tres secciones siguientes son lo que se les escapa.

## ¿Puede una URL de descarga saltarse las reglas de Storage?

Sí. La URL lleva un token en `?token=`, y en mi prueba ese token bastó por sí solo. La regla de arriba seguía en su sitio.

![Un archivo, una regla de propietario, un invitado. Peticiones de un archivo privado sin usuario con sesión. Sin token: Invitado → sin token → 403; Token actual: Invitado → token de descarga → 200; Token leído antes de corregir las reglas: Invitado → token antiguo → 200; Token antiguo, archivo subido de nuevo: Invitado → token antiguo → 403.](https://madsalt.tech/charts/es/firebase-storage-rules.svg)

*Figura 1. Mi prueba en el emulador de Firebase (CLI 15.34.2), 3 de noviembre de 2026.*

| Petición del archivo de B                       | Resultado |
| ----------------------------------------------- | --------- |
| Un invitado, sin token                          | `403`     |
| Un invitado, con el token correcto              | `200`     |
| Un invitado, con un token erróneo               | `403`     |
| A (no es el propietario), con el token correcto | `200`     |

Firebase lo describe como una [URL de larga duración con un token revocable](https://firebase.google.com/docs/reference/kotlin/com/google/firebase/storage/StorageReference), pensada para compartir. El problema empieza cuando una app guarda esa URL en un documento y trata las reglas del documento como la protección del archivo. Quien haya leído la URL alguna vez se queda con el archivo, digan lo que digan sus reglas después.

## ¿Corregir las reglas cierra los enlaces antiguos?

No, y es la parte que revisaría después de cualquier incidente. Lo ejecuté en orden:

1. Con `request.auth != null` activa, un desconocido leyó los metadatos del archivo, `200`. Los metadatos contienen el token de descarga.
2. Cargué la regla solo para el propietario. El desconocido recibió ahora `403` en el archivo y en sus metadatos.
3. Un invitado con el token del paso 1 descargó el archivo, `200`.

Así que si su bucket estuvo abierto alguna vez, endurecer las reglas no recupera los tokens ya leídos. Cuando B subió el archivo de nuevo, la respuesta traía un token nuevo, el antiguo devolvió `403` y el nuevo `200`. Firebase también dice que los tokens [pueden revocarse en la consola](https://firebase.google.com/docs/reference/swift/firebasestorage/api/reference/Classes/StorageReference), cosa que no probé.

Para archivos privados, evite las URL. `getBlob()` y `getBytes()` [descargan a través del SDK](https://firebase.google.com/docs/storage/web/download-files), así que sus reglas se aplican a cada petición.

## ¿Las comprobaciones de tamaño y tipo detienen las subidas malas?

La regla solo para el propietario, sola, aceptó cualquier cosa de A dentro de la carpeta de A: un archivo de 3 MB y una página HTML con un script, ambos `200`. Así que añadí límites:

```
match /users/{uid}/{file=**} {
  allow read: if request.auth != null && request.auth.uid == uid;
  allow write: if request.auth != null && request.auth.uid == uid
    && request.resource.size < 1024 * 1024
    && request.resource.contentType.matches('image/.*');
}
```

| Petición de A                 | Resultado |
| ----------------------------- | --------- |
| PNG pequeño                   | `200`     |
| Archivo de 2 MB               | `403`     |
| HTML enviado como `text/html` | `403`     |
| HTML enviado como `image/png` | `200`     |
| Borrar su propio archivo      | `403`     |

Dos sorpresas. `contentType` es lo que dice el cliente, y la regla nunca mira dentro del archivo. Trátelo como una protección contra errores, no contra alguien que lo intenta. Si un archivo subido importa, compruébelo en un servidor.

Y el usuario ya no podía borrar sus propios archivos. Un borrado no tiene `request.resource`, así que la comprobación llega a un valor nulo, la regla falla y se deniega la petición. El log del emulador mostró `Null value error` en esa línea. Separe las operaciones:

```
allow read, delete: if request.auth != null && request.auth.uid == uid;
allow create, update: if request.auth != null && request.auth.uid == uid
  && request.resource.size < 1024 * 1024
  && request.resource.contentType.matches('image/.*');
```

Ahora el borrado devolvió `204`, y el archivo de 2 MB siguió recibiendo `403`.

## ¿Por qué `allow read` no me deja listar una carpeta?

`read` cubre `get` y `list`, así que esperaba que una carpeta pública se pudiera listar. Dependió del comodín:

| Regla en `public/`                      | Descarga | Listar el prefijo `public/` |
| --------------------------------------- | -------- | --------------------------- |
| `match /public/{file}`, `allow read`    | `200`    | `403`                       |
| `match /public/{file=**}`, `allow read` | `200`    | `200`, 2 archivos           |
| `match /public/{file=**}`, `allow get`  | `200`    | `403`                       |

Así que para recursos públicos, `allow get` en una regla recursiva sirve los archivos y se niega a enumerarlos. Es lo que usaría para todo lo que la gente solo deba alcanzar con el enlace exacto.

## ¿Cómo limitar los archivos a los miembros de una empresa?

Las reglas de Storage pueden leer Firestore, con `firestore.exists()` y `firestore.get()`:

```
match /companies/{cid}/{file=**} {
  allow read, write: if request.auth != null
    && firestore.exists(/databases/(default)/documents/companies/$(cid)/members/$(request.auth.uid));
}
```

Un miembro recibió `200`, un usuario ajeno a la empresa recibió `403`, y un invitado también. Eso solo traslada la pregunta a quién puede escribir la colección `members`, que es otra vez el [problema del rol que escribe el propio usuario](https://madsalt.tech/es/blog/firebase-security-rules-examples/). En un proyecto real, Firebase [le pide activar un permiso](https://firebase.google.com/docs/rules/manage-deploy) que conecta los dos productos, y cada consulta [cuenta como una lectura de Firestore](https://firebase.google.com/docs/storage/security/rules-conditions). No probé ninguna de las dos cosas en el emulador.

## ¿Cómo comprobar su bucket?

- Busque en su base de datos y en su código URL de `firebasestorage` guardadas que apunten a archivos privados.
- Si el bucket estuvo alguna vez abierto o solo con sesión, reemplace o revoque los tokens de todo lo sensible. Corregir las reglas no basta.
- Pruebe una segunda cuenta contra los archivos de la primera, en el [emulador](https://firebase.google.com/docs/rules/insecure-rules) o en un proyecto de prueba.

El [revisor de reglas de Firebase](https://madsalt.tech/es/tools/firebase-rules-checker/) gratuito acepta reglas de Storage pegadas. En estos conjuntos señaló el modo de prueba, las escrituras solo con sesión y las lecturas públicas. Dejó pasar la regla solo para el propietario sin límite de tamaño o tipo, y no puede ver los tokens de descarga, porque ninguno de los dos aparece como una regla abierta. Así que un resultado limpio cubre el texto de las reglas, no los archivos.

**Límites.** Emulador local con archivos de relleno, por REST. No probé Google Cloud IAM en el bucket, la revocación de tokens desde la consola ni cómo un bucket de producción sirve un archivo HTML subido. La producción puede diferir del emulador en detalles que no comprobé.

Los mismos ataques lado a lado en Supabase y Firebase están en [Supabase vs Firebase: seguridad](https://madsalt.tech/es/blog/supabase-vs-firebase-security/).

Ver también: [Gestor documental para pymes: 7 opciones con precios](https://madsalt.tech/es/blog/document-management-software-for-small-business/).

## Mi caso similar

Una empresa para la que construí pagaba miles de dólares al mes por un producto documental empresarial. Su propia plataforma cuesta ahora cientos al mes, con roles para documentos, formularios, informes y un portal de clientes, y solo las funciones que usa el equipo. Vea el [caso de la plataforma documental de obra](https://madsalt.tech/es/work/construction-document-platform/).

¿Guarda archivos que nadie querría ver compartidos? Escríbame y decidiremos cómo debe entregarlos su aplicación.

¿Guarda archivos que no deben compartirse?

Cuénteme lo que tiene ahora y lo que necesita. Le responderé con la opción que yo elegiría.

[Escríbame](https://madsalt.tech/es/#contact)
