---
title: "Firebase Storage-regler: vad jag tog mig förbi"
description: "Firebase Storage-regler testade i emulatorn. Ägarregler höll, men en nedladdnings-URL öppnade filen för en gäst och att rätta reglerna stängde den inte."
url: "https://madsalt.tech/sv/blog/firebase-storage-rules/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/sv/about/"
language: "sv"
published: 2026-11-05
---

# Firebase Storage-regler: vad jag tog mig förbi

Kort sagt

En ägarregel på `users/{uid}/...` stoppade andra användare från att läsa, lista och skriva. Den stoppade inte en gäst som hade filens nedladdnings-URL: den förfrågan gav `200`, och gjorde det fortfarande efter att jag rättat reglerna. En `contentType`-kontroll godtog ett HTML-skript uppladdat som `image/png`. Och en storlekskontroll på `write` hindrade användare från att radera sina egna filer. Att ersätta filen ändrade token och stängde den gamla länken.

Storage-regler ser ut som [Firestore-regler](https://madsalt.tech/sv/blog/firebase-security-rules-examples/), och de flesta guider stannar vid "kontrollera uid i sökvägen". Jag laddade upp platshållarfiler med namn som passbilder och fakturor för att se vad den kontrollen lämnar öppet.

**Så testade jag.** Firebase Local Emulator Suite från Firebase CLI 15.34.2, den 3 november 2026, med Storage- och Auth-emulatorerna. Jag anropade Firebase Storages REST-API med tokens för en gäst, en anonym användare, användarna A och B och en främling som bara registrerat sig. Filerna var några byte platshållardata, plus större filer för storlekstesterna.

## Vad släpper de vanliga Storage-reglerna igenom?

| Regel                  | Förfrågan                     | Resultat       |
| ---------------------- | ----------------------------- | -------------- |
| `if true` (testläge)   | Gäst listar bucketen          | `200`, 4 filer |
| `if true` (testläge)   | Gäst laddar upp en HTML-fil   | `200`          |
| `request.auth != null` | Anonym användare läser Bs fil | `200`          |
| `request.auth != null` | Främling listar bucketen      | `200`, 4 filer |
| `request.auth != null` | Främling skriver över Bs fil  | `200`          |
| `request.auth != null` | Främling raderar As fil       | `204`          |

Regeln enbart för inloggade är den att se upp med. En gäst får `403`, så den klarar en snabb titt, och sedan kan vem som helst med ett konto lista varje sökväg och byta ut ett pass mot vad som helst. Listan ger dem också varje fils namn, som här innehåller ägarens uid.

## Skyddar en ägarregel filen?

Mot andra användare, ja:

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

| Förfrågan              | Resultat     |
| ---------------------- | ------------ |
| Gäst läser Bs fil      | `403`        |
| A läser sin egen fil   | `200`        |
| A läser Bs fil         | `403`        |
| A listar sin egen mapp | `200`, 1 fil |
| A listar Bs mapp       | `403`        |
| A listar hela bucketen | `403`        |
| A skriver över Bs fil  | `403`        |

Det är allt de flesta handledningar testar. De tre nästa avsnitten är vad den missar.

## Kan en nedladdnings-URL kringgå Storage-regler?

Ja. URL:en bär en token i `?token=`, och i min körning räckte den token ensam. Regeln ovan låg kvar.

![En fil, en ägarregel, en gäst. Förfrågningar om en privat fil utan inloggad användare. Ingen token: Gäst → ingen token → 403; Aktuell token: Gäst → nedladdningstoken → 200; Token läst innan reglerna rättades: Gäst → gammal token → 200; Gammal token, filen uppladdad igen: Gäst → gammal token → 403.](https://madsalt.tech/charts/sv/firebase-storage-rules.svg)

*Figur 1. Mitt test i Firebase-emulatorn (CLI 15.34.2), 3 november 2026.*

| Förfrågan om Bs fil         | Resultat |
| --------------------------- | -------- |
| Gäst, ingen token           | `403`    |
| Gäst, rätt token            | `200`    |
| Gäst, fel token             | `403`    |
| A (inte ägaren), rätt token | `200`    |

Firebase beskriver detta som en [långlivad URL med en återkallningsbar token](https://firebase.google.com/docs/reference/kotlin/com/google/firebase/storage/StorageReference), avsedd för delning. Problemet börjar när en app sparar den URL:en i ett dokument och behandlar dokumentets regler som filens skydd. Den som någon gång har läst URL:en behåller filen, vad dina regler än säger senare.

## Stänger en rättning av reglerna gamla länkar?

Nej, och det här är delen jag skulle kontrollera efter varje incident. Jag körde det i ordning:

1. Med `request.auth != null` på plats läste en främling filens metadata, `200`. Metadatan innehåller nedladdningstoken.
2. Jag laddade ägarregeln. Främlingen fick nu `403` på filen och på dess metadata.
3. En gäst som använde token från steg 1 laddade ner filen, `200`.

Så om din bucket någon gång har varit öppen tar en skärpning av reglerna inte tillbaka de tokens som redan lästs. När B laddade upp filen igen bar svaret en ny token, den gamla gav `403` och den nya `200`. Firebase säger också att tokens [kan återkallas i konsolen](https://firebase.google.com/docs/reference/swift/firebasestorage/api/reference/Classes/StorageReference), vilket jag inte testade.

För privata filer, hoppa över URL:er. `getBlob()` och `getBytes()` [laddar ner via SDK:t](https://firebase.google.com/docs/storage/web/download-files), så dina regler gäller för varje förfrågan.

## Stoppar storleks- och typkontroller dåliga uppladdningar?

Enbart ägarregeln godtog allt från A i As mapp: en fil på 3 MB och en HTML-sida med ett skript, båda `200`. Så jag lade till gränser:

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

| Förfrågan från A             | Resultat |
| ---------------------------- | -------- |
| Liten PNG                    | `200`    |
| Fil på 2 MB                  | `403`    |
| HTML skickad som `text/html` | `403`    |
| HTML skickad som `image/png` | `200`    |
| Radera egen fil              | `403`    |

Två överraskningar. `contentType` är vad klienten säger, och regeln tittar aldrig in i filen. Behandla den därför som ett skydd mot misstag, inte mot någon som försöker. Om en uppladdad fil spelar roll, kontrollera den på en server.

Och användaren kunde inte längre radera sina egna filer. En radering har ingen `request.resource`, så kontrollen träffar ett nullvärde, regeln ger fel och förfrågan nekas. Emulatorns logg visade `Null value error` på den raden. Dela upp operationerna:

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

Nu gav raderingen `204`, och filen på 2 MB fick fortfarande `403`.

## Varför låter `allow read` mig inte lista en mapp?

`read` omfattar `get` och `list`, så jag väntade mig att en offentlig mapp skulle gå att lista. Det berodde på jokertecknet:

| Regel på `public/`                      | Nedladdning | Lista prefixet `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å för offentliga tillgångar serverar `allow get` på ett rekursivt match filerna och vägrar räkna upp dem. Det är vad jag skulle använda för allt som folk bara ska nå via den exakta länken.

## Hur begränsar du filer till företagets medlemmar?

Storage-regler kan läsa Firestore, med `firestore.exists()` och `firestore.get()`:

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

En medlem fick `200`, en användare utanför företaget fick `403`, och det fick gästen också. Det flyttar bara frågan till vem som kan skriva till samlingen `members`, vilket återigen är [problemet med den självskrivna rollen](https://madsalt.tech/sv/blog/firebase-security-rules-examples/). I ett riktigt projekt [ber Firebase dig aktivera en behörighet](https://firebase.google.com/docs/rules/manage-deploy) som kopplar ihop de två produkterna, och varje uppslag [räknas som en Firestore-läsning](https://firebase.google.com/docs/storage/security/rules-conditions). Jag testade ingetdera i emulatorn.

## Hur kontrollerar du din bucket?

- Sök i databasen och koden efter sparade `firebasestorage`-URL:er som pekar på privata filer.
- Om bucketen någon gång har varit öppen eller enbart för inloggade, byt ut eller återkalla tokens för allt känsligt. Att rätta reglerna räcker inte.
- Prova ett andra konto mot det första kontots filer, i [emulatorn](https://firebase.google.com/docs/rules/insecure-rules) eller på ett testprojekt.

Den gratis [Firebase regelkontroll](https://madsalt.tech/sv/tools/firebase-rules-checker/) tar emot inklistrade Storage-regler. På de här regeluppsättningarna flaggade den testläget, skrivningar enbart för inloggade och offentliga läsningar. Den släppte igenom ägarregeln utan storleks- eller typgräns, och den kan inte alls se nedladdningstokens, eftersom ingetdera syns som en öppen regel. Ett rent resultat täcker alltså regeltexten, inte filerna.

**Begränsningar.** Lokal emulator på platshållarfiler, över REST. Jag testade inte Google Cloud IAM på bucketen, konsolens tokenåterkallelse eller hur en produktionsbucket serverar en uppladdad HTML-fil. Produktion kan skilja sig från emulatorn i detaljer jag inte kontrollerade.

Samma attacker sida vid sida på Supabase och Firebase finns i [Supabase vs Firebase säkerhet](https://madsalt.tech/sv/blog/supabase-vs-firebase-security/).

Se även: [Bästa dokumenthanteringssystem för småföretag: 8 priser](https://madsalt.tech/sv/blog/document-management-software-for-small-business/).

## Mitt liknande fall

Ett företag jag byggde åt betalade tusentals dollar i månaden för en dokumentprodukt för stora företag. Dess egen plattform kostar nu hundratals i månaden, med roller för dokument, formulär, rapporter och en kundportal, och bara de funktioner teamet använder. Se [caset om byggdokumentplattformen](https://madsalt.tech/sv/work/construction-document-platform/).

Lagrar du filer som folk inte vill ha delade? Skriv till mig, så tar vi reda på hur din app bör dela ut dem.

Lagrar du filer som folk inte vill ha delade?

Berätta vad du har nu och vad du behöver. Jag svarar med det alternativ jag själv skulle välja.

[Skriv till mig](https://madsalt.tech/sv/#contact)
