---
title: "Firebase Storage rules: hva jeg kom forbi"
description: "Firebase Storage rules testet i emulatoren. Regler kun for eieren holdt, men en nedlastingslenke åpnet filen for en gjest, og å rette reglene lukket den ikke."
url: "https://madsalt.tech/no/blog/firebase-storage-rules/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/no/about/"
language: "no"
published: 2026-11-05
---

# Firebase Storage rules: hva jeg kom forbi

TL;DR

En regel kun for eieren på `users/{uid}/...` stoppet andre brukere fra å lese, liste og skrive. Den stoppet ikke en gjest som hadde filens nedlastingslenke: den forespørselen ga `200`, og gjorde det fortsatt etter at jeg hadde rettet reglene. En `contentType`-sjekk godtok et HTML-skript lastet opp som `image/png`. Og en størrelsessjekk på `write` hindret brukere i å slette sine egne filer. Å erstatte filen endret tokenet og lukket den gamle lenken.

Storage-regler ser ut som [Firestore-regler](https://madsalt.tech/no/blog/firebase-security-rules-examples/), og de fleste guider stopper ved «sjekk uid i stien». Jeg lastet opp plassholderfiler med navn som pass og fakturaer for å se hva den sjekken lar stå åpent.

**Slik testet jeg.** Firebase Local Emulator Suite fra Firebase CLI 15.34.2, 3. november 2026, med Storage- og Auth-emulatorene. Jeg kalte Firebase Storage REST API med tokens for en gjest, en anonym bruker, brukerne A og B og en fremmed som bare hadde registrert seg. Filene var noen få byte plassholderdata, pluss større til størrelsestestene.

## Hva slipper vanlige Storage-regler gjennom?

| Regel                  | Forespørsel                  | Resultat       |
| ---------------------- | ---------------------------- | -------------- |
| `if true` (testmodus)  | Gjest lister bucketen        | `200`, 4 filer |
| `if true` (testmodus)  | Gjest laster opp en HTML-fil | `200`          |
| `request.auth != null` | Anonym bruker leser Bs fil   | `200`          |
| `request.auth != null` | Fremmed lister bucketen      | `200`, 4 filer |
| `request.auth != null` | Fremmed overskriver Bs fil   | `200`          |
| `request.auth != null` | Fremmed sletter As fil       | `204`          |

Kun innlogget er den å se opp for. En gjest får `403`, så den består et raskt blikk, og så kan alle med en konto liste hver sti og bytte ut et pass med hva som helst. Listen gir dem også hver fils navn, som her inneholder eierens uid.

## Beskytter en regel kun for eieren filen?

Mot andre brukere, ja:

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

| Forespørsel            | Resultat     |
| ---------------------- | ------------ |
| Gjest leser Bs fil     | `403`        |
| A leser egen fil       | `200`        |
| A leser Bs fil         | `403`        |
| A lister egen mappe    | `200`, 1 fil |
| A lister Bs mappe      | `403`        |
| A lister hele bucketen | `403`        |
| A overskriver Bs fil   | `403`        |

Det er alt de fleste veiledninger tester. De tre neste avsnittene er det den overser.

## Kan en nedlastingslenke omgå Storage-regler?

Ja. Lenken har et token i `?token=`, og i kjøringen min var det tokenet nok alene. Regelen over var fortsatt på plass.

![Én fil, én regel kun for eieren, én gjest. Forespørsler om en privat fil uten innlogget bruker. Uten token: Gjest → uten token → 403; Gjeldende token: Gjest → nedlastingstoken → 200; Token lest før reglene ble rettet: Gjest → gammelt token → 200; Gammelt token, filen lastet opp på nytt: Gjest → gammelt token → 403.](https://madsalt.tech/charts/no/firebase-storage-rules.svg)

*Figur 1. Testen min i Firebase-emulatoren (CLI 15.34.2), 3. november 2026.*

| Forespørsel om Bs fil       | Resultat |
| --------------------------- | -------- |
| Gjest, uten token           | `403`    |
| Gjest, riktig token         | `200`    |
| Gjest, feil token           | `403`    |
| A (ikke eier), riktig token | `200`    |

Firebase beskriver dette som en [langlivet URL med et token som kan trekkes tilbake](https://firebase.google.com/docs/reference/kotlin/com/google/firebase/storage/StorageReference), laget for deling. Trøbbelet starter når en app lagrer den URL-en i et dokument og regner dokumentets regler som filens beskyttelse. Alle som noen gang har lest URL-en, beholder filen, uansett hva reglene dine sier senere.

## Lukker det gamle lenker å rette reglene?

Nei, og dette er delen jeg ville sjekket etter enhver hendelse. Jeg kjørte det i rekkefølge:

1. Med `request.auth != null` på plass leste en fremmed filens metadata, `200`. Metadataene inneholder nedlastingstokenet.
2. Jeg lastet regelen kun for eieren. Den fremmede fikk nå `403` på filen og på metadataene.
3. En gjest med tokenet fra steg 1 lastet ned filen, `200`.

Så hvis bucketen din noen gang var åpen, tar ikke strammere regler tilbake tokens som allerede er lest. Da B lastet opp filen på nytt, hadde svaret et nytt token, det gamle ga `403` og det nye `200`. Firebase sier også at tokens [kan trekkes tilbake i konsollen](https://firebase.google.com/docs/reference/swift/firebasestorage/api/reference/Classes/StorageReference), noe jeg ikke testet.

For private filer, hopp over URL-er. `getBlob()` og `getBytes()` [laster ned via SDK-en](https://firebase.google.com/docs/storage/web/download-files), så reglene dine gjelder for hver forespørsel.

## Stopper størrelses- og typesjekker dårlige opplastinger?

Regelen kun for eieren alene godtok hva som helst fra A i As egen mappe: en fil på 3 MB og en HTML-side med et skript, begge `200`. Så jeg la til grenser:

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

| Forespørsel fra A          | Resultat |
| -------------------------- | -------- |
| Liten PNG                  | `200`    |
| Fil på 2 MB                | `403`    |
| HTML sendt som `text/html` | `403`    |
| HTML sendt som `image/png` | `200`    |
| Slette egen fil            | `403`    |

To overraskelser. `contentType` er det klienten sier, og regelen ser aldri inni filen. Behandle den derfor som et vern mot feil, ikke mot noen som prøver. Hvis en opplastet fil betyr noe, sjekk den på en server.

Og brukeren kunne ikke lenger slette sine egne filer. En sletting har ingen `request.resource`, så sjekken treffer en null-verdi, regelen feiler og forespørselen avvises. Emulatorloggen viste `Null value error` på den linjen. Del opp operasjonene:

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

Nå ga slettingen `204`, og filen på 2 MB fikk fortsatt `403`.

## Hvorfor lar ikke `allow read` meg liste en mappe?

`read` dekker `get` og `list`, så jeg forventet at en offentlig mappe kunne listes. Det kom an på wildcardet:

| Regel på `public/`                      | Nedlasting | Liste prefikset `public/` |
| --------------------------------------- | ---------- | ------------------------- |
| `match /public/{file}`, `allow read`    | `200`      | `403`                     |
| `match /public/{file=**}`, `allow read` | `200`      | `200`, 2 filer            |
| `match /public/{file=**}`, `allow get`  | `200`      | `403`                     |

Så for offentlige ressurser serverer `allow get` på et rekursivt match filene og nekter å liste dem. Det er det jeg ville brukt for alt folk bare skal nå med den eksakte lenken.

## Hvordan begrenser du filer til selskapsmedlemmer?

Storage-regler kan lese Firestore med `firestore.exists()` og `firestore.get()`:

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

Et medlem fikk `200`, en bruker utenfor selskapet fikk `403`, og det samme fikk en gjest. Det flytter bare spørsmålet til hvem som kan skrive samlingen `members`, som er [problemet med selvskrevet rolle](https://madsalt.tech/no/blog/firebase-security-rules-examples/) igjen. I et ekte prosjekt [ber Firebase deg slå på en tillatelse](https://firebase.google.com/docs/rules/manage-deploy) som kobler de to produktene, og hvert oppslag [teller som en Firestore-lesing](https://firebase.google.com/docs/storage/security/rules-conditions). Ingen av delene testet jeg i emulatoren.

## Hvordan sjekker du bucketen din?

- Søk i databasen og koden din etter lagrede `firebasestorage`-URL-er som peker til private filer.
- Hvis bucketen noen gang var åpen eller kun for innloggede, bytt ut eller trekk tilbake tokens for alt sensitivt. Å rette reglene er ikke nok.
- Prøv en andre konto mot den første kontoens filer, i [emulatoren](https://firebase.google.com/docs/rules/insecure-rules) eller på et testprosjekt.

Den gratis [Firebase regelsjekk](https://madsalt.tech/no/tools/firebase-rules-checker/) tar imot limte inn Storage-regler. På disse regelsettene flagget den testmodus, skriving kun for innloggede og offentlig lesing. Den slapp gjennom regelen kun for eieren uten størrelses- eller typegrense, og den ser ikke nedlastingstokens i det hele tatt, siden ingen av dem vises som en åpen regel. Så et rent resultat dekker regelteksten, ikke filene.

**Begrensninger.** Lokal emulator på plassholderfiler, over REST. Jeg testet ikke Google Cloud IAM på bucketen, tilbaketrekking av tokens i konsollen eller hvordan en produksjonsbucket serverer en opplastet HTML-fil. Produksjon kan avvike fra emulatoren i detaljer jeg ikke sjekket.

De samme angrepene side om side på Supabase og Firebase står i [Supabase vs Firebase sikkerhet](https://madsalt.tech/no/blog/supabase-vs-firebase-security/).

Se også: [Dokumenthåndteringssystem for små bedrifter: 8 priset](https://madsalt.tech/no/blog/document-management-software-for-small-business/).

## Mitt tilsvarende tilfelle

Et selskap jeg bygde for betalte tusenvis av dollar i måneden for et dokumentprodukt for store virksomheter. Egen plattform koster nå hundrevis i måneden, med roller for dokumenter, skjemaer, rapporter og en kundeportal, og bare funksjonene teamet bruker. Se [caset om byggedokumentplattformen](https://madsalt.tech/no/work/construction-document-platform/).

Lagrer du filer folk ikke vil ha delt? Skriv til meg, så finner vi ut hvordan appen din bør dele dem ut.

Lagrer du filer folk ikke vil ha delt?

Fortell meg hva du har nå og hva du trenger. Jeg svarer med alternativet jeg selv ville valgt.

[Skriv til meg](https://madsalt.tech/no/#contact)
