---
title: "Regras do Firebase Storage: o que consegui contornar"
description: "Regras do Firebase Storage testadas. As regras só do dono aguentaram, mas um URL de download abriu o ficheiro a um convidado e corrigir as regras não o fechou."
url: "https://madsalt.tech/pt/blog/firebase-storage-rules/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/pt/about/"
language: "pt"
published: 2026-11-05
---

# Regras do Firebase Storage: o que consegui contornar

Em resumo

Uma regra só do dono em `users/{uid}/...` impediu outros utilizadores de ler, listar e escrever. Não impediu um convidado com o URL de download do ficheiro: esse pedido devolveu `200`, e continuou a devolver depois de eu corrigir as regras. Uma verificação de `contentType` aceitou um script HTML enviado como `image/png`. E uma verificação de tamanho em `write` impediu os utilizadores de apagarem os próprios ficheiros. Substituir o ficheiro mudou o token e fechou o link antigo.

As regras do Storage parecem-se com as [regras do Firestore](https://madsalt.tech/pt/blog/firebase-security-rules-examples/), e a maioria dos guias fica em "verifique o uid no caminho". Enviei ficheiros de exemplo com nomes de passaportes e faturas para ver o que essa verificação deixa aberto.

**Como testei.** Firebase Local Emulator Suite do Firebase CLI 15.34.2, a 3 de novembro de 2026, com os emuladores de Storage e Auth. Chamei a API REST do Firebase Storage com tokens de um convidado, de um utilizador anónimo, dos utilizadores A e B e de um estranho que apenas se registou. Os ficheiros eram alguns bytes de dados de exemplo, mais outros maiores para os testes de tamanho.

## O que deixam passar as regras habituais do Storage?

| Regra                     | Pedido                                | Resultado          |
| ------------------------- | ------------------------------------- | ------------------ |
| `if true` (modo de teste) | Convidado lista o bucket              | `200`, 4 ficheiros |
| `if true` (modo de teste) | Convidado envia um ficheiro HTML      | `200`              |
| `request.auth != null`    | Utilizador anónimo lê o ficheiro de B | `200`              |
| `request.auth != null`    | Estranho lista o bucket               | `200`, 4 ficheiros |
| `request.auth != null`    | Estranho sobrescreve o ficheiro de B  | `200`              |
| `request.auth != null`    | Estranho apaga o ficheiro de A        | `204`              |

A regra só com sessão iniciada é a que merece atenção. Um convidado recebe `403`, por isso passa num olhar rápido, e depois qualquer pessoa com uma conta pode listar todos os caminhos e trocar um passaporte por qualquer coisa. A lista também lhe entrega o nome de cada ficheiro, que aqui contém o uid do dono.

## Uma regra só do dono protege o ficheiro?

Contra outros utilizadores, sim:

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

| Pedido                        | Resultado         |
| ----------------------------- | ----------------- |
| Convidado lê o ficheiro de B  | `403`             |
| A lê o próprio ficheiro       | `200`             |
| A lê o ficheiro de B          | `403`             |
| A lista a própria pasta       | `200`, 1 ficheiro |
| A lista a pasta de B          | `403`             |
| A lista o bucket inteiro      | `403`             |
| A sobrescreve o ficheiro de B | `403`             |

É tudo o que a maioria dos tutoriais testa. As três secções seguintes são o que fica de fora.

## Um URL de download contorna as regras do Storage?

Sim. O URL leva um token em `?token=`, e na minha execução esse token bastou sozinho. A regra acima manteve-se em vigor.

![Um ficheiro, uma regra só do dono, um convidado. Pedidos de um ficheiro privado sem utilizador autenticado. Sem token: Convidado → sem token → 403; Token atual: Convidado → token de download → 200; Token lido antes de corrigir as regras: Convidado → token antigo → 200; Token antigo, ficheiro enviado de novo: Convidado → token antigo → 403.](https://madsalt.tech/charts/pt/firebase-storage-rules.svg)

*Figura 1. O meu teste no emulador do Firebase (CLI 15.34.2), 3 de novembro de 2026.*

| Pedido do ficheiro de B         | Resultado |
| ------------------------------- | --------- |
| Convidado, sem token            | `403`     |
| Convidado, token correto        | `200`     |
| Convidado, token errado         | `403`     |
| A (não é o dono), token correto | `200`     |

O Firebase descreve isto como um [URL de longa duração com um token revogável](https://firebase.google.com/docs/reference/kotlin/com/google/firebase/storage/StorageReference), pensado para partilhar. O problema começa quando uma app guarda esse URL num documento e trata as regras do documento como proteção do ficheiro. Quem alguma vez leu o URL fica com o ficheiro, digam as suas regras o que disserem depois.

## Corrigir as regras fecha os links antigos?

Não, e é a parte que eu verificaria depois de qualquer incidente. Fi-lo por ordem:

1. Com `request.auth != null` em vigor, um estranho leu os metadados do ficheiro, `200`. Os metadados contêm o token de download.
2. Carreguei a regra só do dono. O estranho passou a receber `403` no ficheiro e nos seus metadados.
3. Um convidado com o token do passo 1 descarregou o ficheiro, `200`.

Ou seja, se o seu bucket esteve alguma vez aberto, apertar as regras não recupera os tokens já lidos. Quando B enviou o ficheiro outra vez, a resposta trouxe um token novo, o antigo devolveu `403` e o novo `200`. O Firebase diz também que os tokens [podem ser revogados na consola](https://firebase.google.com/docs/reference/swift/firebasestorage/api/reference/Classes/StorageReference), o que não testei.

Para ficheiros privados, dispense URLs. `getBlob()` e `getBytes()` [descarregam através do SDK](https://firebase.google.com/docs/storage/web/download-files), por isso as suas regras aplicam-se a cada pedido.

## As verificações de tamanho e de tipo travam envios maus?

A regra só do dono, sozinha, aceitou tudo de A dentro da pasta de A: um ficheiro de 3 MB e uma página HTML com um script, ambos `200`. Por isso acrescentei limites:

```
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/.*');
}
```

| Pedido de A                   | Resultado |
| ----------------------------- | --------- |
| PNG pequeno                   | `200`     |
| Ficheiro de 2 MB              | `403`     |
| HTML enviado como `text/html` | `403`     |
| HTML enviado como `image/png` | `200`     |
| Apagar o próprio ficheiro     | `403`     |

Duas surpresas. O `contentType` é o que o cliente diz, e a regra nunca olha para dentro do ficheiro. Por isso trate-o como proteção contra enganos, não contra quem tenta. Se um ficheiro enviado importa, verifique-o num servidor.

E o utilizador deixou de poder apagar os próprios ficheiros. Um delete não tem `request.resource`, por isso a verificação bate num valor nulo, a regra dá erro e o pedido é recusado. O log do emulador mostrou `Null value error` nessa linha. Separe as operações:

```
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/.*');
```

Agora o delete devolveu `204`, e o ficheiro de 2 MB continuou a receber `403`.

## Porque é que `allow read` não me deixa listar uma pasta?

`read` cobre `get` e `list`, por isso esperava que uma pasta pública fosse listável. Dependeu do wildcard:

| Regra em `public/`                      | Download | Listar o prefixo `public/` |
| --------------------------------------- | -------- | -------------------------- |
| `match /public/{file}`, `allow read`    | `200`    | `403`                      |
| `match /public/{file=**}`, `allow read` | `200`    | `200`, 2 ficheiros         |
| `match /public/{file=**}`, `allow get`  | `200`    | `403`                      |

Assim, para ativos públicos, `allow get` num match recursivo serve os ficheiros e recusa enumerá-los. É o que eu usaria para tudo o que as pessoas só devem alcançar pelo link exato.

## Como limitar ficheiros aos membros de uma empresa?

As regras do Storage podem ler o Firestore, com `firestore.exists()` e `firestore.get()`:

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

Um membro recebeu `200`, um utilizador de fora da empresa recebeu `403`, e o convidado também. Isso só desloca a pergunta para quem pode escrever a coleção `members`, que é outra vez o [problema da função escrita pelo próprio utilizador](https://madsalt.tech/pt/blog/firebase-security-rules-examples/). Num projeto real, o Firebase [pede que ative uma permissão](https://firebase.google.com/docs/rules/manage-deploy) a ligar os dois produtos, e cada consulta [conta como uma leitura do Firestore](https://firebase.google.com/docs/storage/security/rules-conditions). Não testei nenhuma das duas no emulador.

## Como verificar o seu bucket?

- Procure na base de dados e no código URLs `firebasestorage` guardados que apontem para ficheiros privados.
- Se o bucket esteve alguma vez aberto ou só com sessão iniciada, substitua ou revogue os tokens de tudo o que seja sensível. Corrigir as regras não chega.
- Experimente uma segunda conta contra os ficheiros da primeira, no [emulador](https://firebase.google.com/docs/rules/insecure-rules) ou num projeto de teste.

O [Verificador de regras Firebase](https://madsalt.tech/pt/tools/firebase-rules-checker/) gratuito aceita regras de Storage coladas. Nestes conjuntos de regras assinalou o modo de teste, as escritas só com sessão iniciada e as leituras públicas. Deixou passar a regra só do dono sem limite de tamanho nem de tipo, e não vê de todo os tokens de download, já que nenhum dos dois aparece como regra aberta. Por isso um resultado limpo cobre o texto das regras, não os ficheiros.

**Limites.** Emulador local com ficheiros de exemplo, por REST. Não testei o Google Cloud IAM no bucket, a revogação de tokens na consola, nem como um bucket de produção serve um ficheiro HTML enviado. A produção pode diferir do emulador em pormenores que não verifiquei.

Os mesmos ataques lado a lado no Supabase e no Firebase estão em [segurança Supabase vs Firebase](https://madsalt.tech/pt/blog/supabase-vs-firebase-security/).

Ver também: [Software de gestão documental para PME: 5 opções](https://madsalt.tech/pt/blog/document-management-software-for-small-business/).

## O meu caso semelhante

Uma empresa para quem construí pagava milhares de dólares por mês por um produto documental empresarial. A plataforma própria custa agora centenas por mês, com funções para documentos, formulários, relatórios e um portal de clientes, e só as funcionalidades que a equipa usa. Veja o [caso da plataforma documental de obra](https://madsalt.tech/pt/work/construction-document-platform/).

Guarda ficheiros que ninguém queria ver partilhados? Escreva-me e decidimos como a sua aplicação os deve entregar.

Guarda ficheiros que não devem ser partilhados?

Diga-me o que tem agora e o que precisa. Respondo com a opção que eu escolheria.

[Fale comigo](https://madsalt.tech/pt/#contact)
