---
title: "Regole Firebase Storage: cosa ho aggirato"
description: "Regole Firebase Storage testate nell’emulatore. Quelle solo per il proprietario hanno retto, ma un URL di download apriva il file a un ospite."
url: "https://madsalt.tech/it/blog/firebase-storage-rules/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/it/about/"
language: "it"
published: 2026-11-05
---

# Regole Firebase Storage: cosa ho aggirato

In breve

Una regola solo per il proprietario su `users/{uid}/...` ha impedito agli altri utenti di leggere, elencare e scrivere. Non ha fermato un ospite in possesso dell'URL di download del file: quella richiesta ha restituito `200`, e lo ha fatto anche dopo che avevo corretto le regole. Un controllo su `contentType` ha accettato uno script HTML caricato come `image/png`. E un controllo sulla dimensione in `write` ha impedito agli utenti di eliminare i propri file. Sostituire il file ha cambiato il token e chiuso il vecchio link.

Le regole di Storage somigliano alle [regole di Firestore](https://madsalt.tech/it/blog/firebase-security-rules-examples/), e la maggior parte delle guide si ferma a «controlli l'uid nel percorso». Ho caricato file segnaposto con nomi da passaporti e fatture per vedere cosa lascia aperto quel controllo.

**Come ho testato.** Firebase Local Emulator Suite da Firebase CLI 15.34.2, il 3 novembre 2026, con gli emulatori Storage e Auth. Ho chiamato l'API REST di Firebase Storage con token per un ospite, un utente anonimo, gli utenti A e B, e un estraneo che si era solo registrato. I file erano pochi byte di dati segnaposto, più file più grandi per i test sulla dimensione.

## Cosa lasciano passare le regole Storage più comuni?

| Regola                    | Richiesta                           | Risultato     |
| ------------------------- | ----------------------------------- | ------------- |
| `if true` (modalità test) | L'ospite elenca il bucket           | `200`, 4 file |
| `if true` (modalità test) | L'ospite carica un file HTML        | `200`         |
| `request.auth != null`    | L'utente anonimo legge il file di B | `200`         |
| `request.auth != null`    | L'estraneo elenca il bucket         | `200`, 4 file |
| `request.auth != null`    | L'estraneo sovrascrive il file di B | `200`         |
| `request.auth != null`    | L'estraneo elimina il file di A     | `204`         |

Quella solo per utenti autenticati è la regola da tenere d'occhio. Un ospite riceve `403`, quindi regge a un'occhiata veloce, e poi chiunque abbia un account può elencare ogni percorso e sostituire un passaporto con qualsiasi cosa. L'elenco gli consegna anche il nome di ogni file, che qui contiene l'uid del proprietario.

## Una regola solo per il proprietario protegge il file?

Contro gli altri utenti, sì:

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

| Richiesta                    | Risultato     |
| ---------------------------- | ------------- |
| L'ospite legge il file di B  | `403`         |
| A legge il proprio file      | `200`         |
| A legge il file di B         | `403`         |
| A elenca la propria cartella | `200`, 1 file |
| A elenca la cartella di B    | `403`         |
| A elenca l'intero bucket     | `403`         |
| A sovrascrive il file di B   | `403`         |

È tutto ciò che la maggior parte dei tutorial testa. Le prossime tre sezioni sono ciò che non vede.

## Un URL di download può aggirare le regole di Storage?

Sì. L'URL porta un token in `?token=`, e nella mia prova quel token bastava da solo. La regola qui sopra è rimasta al suo posto.

![Un file, una regola del proprietario, un ospite. Richieste per un file privato senza utente autenticato. Nessun token: Ospite → nessun token → 403; Token attuale: Ospite → token di download → 200; Token letto prima di correggere le regole: Ospite → vecchio token → 200; Vecchio token, file ricaricato: Ospite → vecchio token → 403.](https://madsalt.tech/charts/it/firebase-storage-rules.svg)

*Figura 1. Il mio test nell’emulatore Firebase (CLI 15.34.2), 3 novembre 2026.*

| Richiesta per il file di B              | Risultato |
| --------------------------------------- | --------- |
| Ospite, senza token                     | `403`     |
| Ospite, token corretto                  | `200`     |
| Ospite, token sbagliato                 | `403`     |
| A (non il proprietario), token corretto | `200`     |

Firebase lo descrive come un [URL di lunga durata con un token revocabile](https://firebase.google.com/docs/reference/kotlin/com/google/firebase/storage/StorageReference), pensato per la condivisione. Il guaio comincia quando un'app salva quell'URL in un documento e considera le regole del documento come la protezione del file. Chiunque abbia mai letto l'URL tiene il file, qualunque cosa dicano poi le Sue regole.

## Correggere le regole chiude i vecchi link?

No, ed è la parte che controllerei dopo qualsiasi incidente. L'ho eseguito in ordine:

1. Con `request.auth != null` attivo, un estraneo ha letto i metadati del file, `200`. I metadati contengono il token di download.
2. Ho caricato la regola solo per il proprietario. L'estraneo ha ricevuto `403` sul file e sui suoi metadati.
3. Un ospite con il token del passo 1 ha scaricato il file, `200`.

Quindi se il Suo bucket è stato mai aperto, stringere le regole non riprende i token già letti. Quando B ha ricaricato il file, la risposta portava un nuovo token, il vecchio ha restituito `403` e il nuovo `200`. Firebase dice anche che i token [possono essere revocati dalla console](https://firebase.google.com/docs/reference/swift/firebasestorage/api/reference/Classes/StorageReference), cosa che non ho testato.

Per i file privati, eviti gli URL. `getBlob()` e `getBytes()` [scaricano tramite l'SDK](https://firebase.google.com/docs/storage/web/download-files), quindi le Sue regole valgono per ogni richiesta.

## I controlli su dimensione e tipo fermano i caricamenti sbagliati?

La sola regola per il proprietario accettava qualsiasi cosa da A nella cartella di A: un file da 3 MB e una pagina HTML con uno script, entrambi `200`. Ho quindi aggiunto dei limiti:

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

| Richiesta di A                | Risultato |
| ----------------------------- | --------- |
| PNG piccolo                   | `200`     |
| File da 2 MB                  | `403`     |
| HTML inviato come `text/html` | `403`     |
| HTML inviato come `image/png` | `200`     |
| Eliminare il proprio file     | `403`     |

Due sorprese. `contentType` è ciò che dice il client, e la regola non guarda mai dentro il file. Lo consideri quindi una protezione contro gli errori, non contro chi ci prova. Se un file caricato è importante, lo controlli su un server.

E l'utente non poteva più eliminare i propri file. Un'eliminazione non ha `request.resource`, quindi il controllo trova un valore nullo, la regola va in errore e la richiesta è negata. Il log dell'emulatore mostrava `Null value error` su quella riga. Separi le operazioni:

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

Ora l'eliminazione ha restituito `204`, e il file da 2 MB ha ancora ricevuto `403`.

## Perché `allow read` non mi fa elencare una cartella?

`read` copre `get` e `list`, quindi mi aspettavo che una cartella pubblica si potesse elencare. Dipendeva dal carattere jolly:

| Regola su `public/`                     | Download | Elenco del prefisso `public/` |
| --------------------------------------- | -------- | ----------------------------- |
| `match /public/{file}`, `allow read`    | `200`    | `403`                         |
| `match /public/{file=**}`, `allow read` | `200`    | `200`, 2 file                 |
| `match /public/{file=**}`, `allow get`  | `200`    | `403`                         |

Quindi per le risorse pubbliche, `allow get` su un match ricorsivo serve i file e rifiuta di enumerarli. È ciò che userei per tutto ciò che le persone devono raggiungere solo con il link esatto.

## Come si limitano i file ai membri di un'azienda?

Le regole di Storage possono leggere Firestore, con `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));
}
```

Un membro ha ricevuto `200`, un utente esterno all'azienda `403`, e così un ospite. Questo sposta solo la domanda su chi può scrivere la collezione `members`, cioè di nuovo il [problema del ruolo scritto dall'utente](https://madsalt.tech/it/blog/firebase-security-rules-examples/). Su un progetto reale, Firebase [chiede di abilitare un'autorizzazione](https://firebase.google.com/docs/rules/manage-deploy) che collega i due prodotti, e ogni consultazione [conta come una lettura Firestore](https://firebase.google.com/docs/storage/security/rules-conditions). Non ho testato né l'una né l'altra nell'emulatore.

## Come si controlla il proprio bucket?

- Cerchi nel database e nel codice gli URL `firebasestorage` salvati che puntano a file privati.
- Se il bucket è stato mai aperto o solo per utenti autenticati, sostituisca o revochi i token di tutto ciò che è sensibile. Correggere le regole non basta.
- Provi un secondo account sui file del primo, nell'[emulatore](https://firebase.google.com/docs/rules/insecure-rules) o su un progetto di prova.

Il [Controllo regole Firebase](https://madsalt.tech/it/tools/firebase-rules-checker/) gratuito accetta regole Storage incollate. Su questi set di regole ha segnalato la modalità test, le scritture solo per utenti autenticati e le letture pubbliche. Ha lasciato passare la regola solo per il proprietario senza limiti di dimensione o tipo, e non vede affatto i token di download, perché nessuno dei due appare come regola aperta. Un risultato pulito copre quindi il testo delle regole, non i file.

**Limiti.** Emulatore locale su file segnaposto, via REST. Non ho testato Google Cloud IAM sul bucket, la revoca dei token dalla console, né come un bucket di produzione serva un file HTML caricato. La produzione può differire dall'emulatore in dettagli che non ho verificato.

Gli stessi attacchi affiancati su Supabase e Firebase sono in [sicurezza Supabase vs Firebase](https://madsalt.tech/it/blog/supabase-vs-firebase-security/).

Vedi anche: [Software di gestione documentale per PMI: 5 con i prezzi](https://madsalt.tech/it/blog/document-management-software-for-small-business/).

## Il mio caso simile

Un'azienda per cui ho costruito pagava migliaia di dollari al mese per un prodotto documentale enterprise. La sua piattaforma ora costa qualche centinaio al mese, con ruoli per documenti, moduli, report e un portale clienti, e solo le funzioni che il team usa. Vedi il [caso della piattaforma documentale per cantieri](https://madsalt.tech/it/work/construction-document-platform/).

Archivia file che nessuno vorrebbe vedere condivisi? Mi scriva e decideremo come la sua app deve consegnarli.

Archivia file che non vanno condivisi?

Mi dica cosa ha adesso e cosa le serve. Le risponderò con l'opzione che sceglierei io.

[Mi scriva](https://madsalt.tech/it/#contact)
