Vai al contenuto

Regole Firebase Storage: cosa ho aggirato

Visualizza come MarkdownApri in ClaudeApri in ChatGPTApri in Perplexity

Anche la domanda viene copiata. Se la chat si apre vuota, la incolli.

In questa pagina
  1. Cosa lasciano passare le regole Storage più comuni?
  2. Una regola solo per il proprietario protegge il file?
  3. Un URL di download può aggirare le regole di Storage?
  4. Correggere le regole chiude i vecchi link?
  5. I controlli su dimensione e tipo fermano i caricamenti sbagliati?
  6. Perché allow read non mi fa elencare una cartella?
  7. Come si limitano i file ai membri di un’azienda?
  8. Come si controlla il proprio bucket?
  9. Il mio caso simile

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, 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.
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, 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.

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, cosa che non ho testato.

Per i file privati, eviti gli URL. getBlob() e getBytes() scaricano tramite l’SDK, 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. Su un progetto reale, Firebase chiede di abilitare un’autorizzazione che collega i due prodotti, e ogni consultazione conta come una lettura Firestore. 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 o su un progetto di prova.

Il Controllo regole Firebase 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.

Vedi anche: Software di gestione documentale per PMI: 5 con i prezzi.

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.

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

© 2026 Denys Zaichenko. Articolo originale: https://madsalt.tech/it/blog/firebase-storage-rules/