---
title: "Règles Firebase Storage : ce que j’ai contourné"
description: "Règles Firebase Storage testées dans l’émulateur. Les règles réservées au propriétaire ont tenu, mais une URL de téléchargement ouvrait le fichier à un invité."
url: "https://madsalt.tech/fr/blog/firebase-storage-rules/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/fr/about/"
language: "fr"
published: 2026-11-05
---

# Règles Firebase Storage : ce que j’ai contourné

En bref

Une règle réservée au propriétaire sur `users/{uid}/...` a empêché les autres utilisateurs de lire, lister et écrire. Elle n’a pas arrêté un invité qui détenait l’URL de téléchargement du fichier : cette requête a renvoyé `200`, et c’est resté vrai après que j’ai corrigé les règles. Un contrôle `contentType` a accepté un script HTML envoyé comme `image/png`. Et un contrôle de taille sur `write` a empêché les utilisateurs de supprimer leurs propres fichiers. Remplacer le fichier a changé le jeton et fermé l’ancien lien.

Les règles Storage ressemblent aux [règles Firestore](https://madsalt.tech/fr/blog/firebase-security-rules-examples/), et la plupart des guides s’arrêtent à « vérifiez l’uid dans le chemin ». J’ai envoyé des fichiers factices nommés comme des passeports et des factures pour voir ce que ce contrôle laisse ouvert.

**Comment j’ai testé.** Firebase Local Emulator Suite de Firebase CLI 15.34.2, le 3 novembre 2026, avec les émulateurs Storage et Auth. J’ai appelé l’API REST de Firebase Storage avec des jetons pour un invité, un utilisateur anonyme, les utilisateurs A et B, et un inconnu qui venait seulement de s’inscrire. Les fichiers étaient quelques octets de données factices, plus des fichiers plus gros pour les tests de taille.

## Que laissent passer les règles Storage courantes ?

| Règle                  | Requête                                   | Résultat          |
| ---------------------- | ----------------------------------------- | ----------------- |
| `if true` (mode test)  | L’invité liste le bucket                  | `200`, 4 fichiers |
| `if true` (mode test)  | L’invité envoie un fichier HTML           | `200`             |
| `request.auth != null` | L’utilisateur anonyme lit le fichier de B | `200`             |
| `request.auth != null` | L’inconnu liste le bucket                 | `200`, 4 fichiers |
| `request.auth != null` | L’inconnu écrase le fichier de B          | `200`             |
| `request.auth != null` | L’inconnu supprime le fichier de A        | `204`             |

Le mode réservé aux utilisateurs connectés est celui à surveiller. Un invité reçoit `403`, donc il passe un coup d’œil rapide, et ensuite toute personne avec un compte peut lister chaque chemin et remplacer un passeport par n’importe quoi. La liste lui donne aussi le nom de chaque fichier, qui contient ici l’uid du propriétaire.

## Une règle réservée au propriétaire protège-t-elle le fichier ?

Contre les autres utilisateurs, oui :

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

| Requête                      | Résultat         |
| ---------------------------- | ---------------- |
| L’invité lit le fichier de B | `403`            |
| A lit son propre fichier     | `200`            |
| A lit le fichier de B        | `403`            |
| A liste son propre dossier   | `200`, 1 fichier |
| A liste le dossier de B      | `403`            |
| A liste tout le bucket       | `403`            |
| A écrase le fichier de B     | `403`            |

C’est tout ce que la plupart des tutoriels testent. Les trois sections suivantes sont ce qu’il rate.

## Une URL de téléchargement peut-elle contourner les règles Storage ?

Oui. L’URL contient un jeton dans `?token=`, et dans mon essai ce jeton suffisait à lui seul. La règle ci-dessus restait en place.

![Un fichier, une règle propriétaire, un invité. Requêtes sur un fichier privé sans utilisateur connecté. Sans jeton: Invité → sans jeton → 403; Jeton actuel: Invité → jeton de téléchargement → 200; Jeton lu avant la correction des règles: Invité → ancien jeton → 200; Ancien jeton, fichier renvoyé: Invité → ancien jeton → 403.](https://madsalt.tech/charts/fr/firebase-storage-rules.svg)

*Figure 1. Mon test dans l’émulateur Firebase (CLI 15.34.2), 3 novembre 2026.*

| Requête pour le fichier de B       | Résultat |
| ---------------------------------- | -------- |
| Invité, sans jeton                 | `403`    |
| Invité, bon jeton                  | `200`    |
| Invité, mauvais jeton              | `403`    |
| A (pas le propriétaire), bon jeton | `200`    |

Firebase décrit cela comme une [URL de longue durée avec un jeton révocable](https://firebase.google.com/docs/reference/kotlin/com/google/firebase/storage/StorageReference), faite pour le partage. Le problème commence quand une application enregistre cette URL dans un document et traite les règles du document comme la protection du fichier. Quiconque a déjà lu l’URL garde le fichier, quelles que soient vos règles ensuite.

## Corriger les règles ferme-t-il les anciens liens ?

Non, et c’est la partie que je vérifierais après tout incident. Je l’ai exécuté dans l’ordre :

1. Avec `request.auth != null` en place, un inconnu a lu les métadonnées du fichier, `200`. Les métadonnées contiennent le jeton de téléchargement.
2. J’ai chargé la règle réservée au propriétaire. L’inconnu a alors reçu `403` sur le fichier et sur ses métadonnées.
3. Un invité utilisant le jeton de l’étape 1 a téléchargé le fichier, `200`.

Donc si votre bucket a un jour été ouvert, durcir les règles ne reprend pas les jetons déjà lus. Quand B a renvoyé le fichier, la réponse contenait un nouveau jeton, l’ancien a renvoyé `403` et le nouveau `200`. Firebase indique aussi que les jetons [peuvent être révoqués dans la console](https://firebase.google.com/docs/reference/swift/firebasestorage/api/reference/Classes/StorageReference), ce que je n’ai pas testé.

Pour les fichiers privés, évitez les URL. `getBlob()` et `getBytes()` [téléchargent via le SDK](https://firebase.google.com/docs/storage/web/download-files), donc vos règles s’appliquent à chaque requête.

## Les contrôles de taille et de type bloquent-ils les mauvais envois ?

La règle réservée au propriétaire seule acceptait tout de A dans le dossier de A : un fichier de 3 Mo et une page HTML avec un script, tous deux `200`. J’ai donc ajouté des 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/.*');
}
```

| Requête de A                  | Résultat |
| ----------------------------- | -------- |
| Petit PNG                     | `200`    |
| Fichier de 2 Mo               | `403`    |
| HTML envoyé comme `text/html` | `403`    |
| HTML envoyé comme `image/png` | `200`    |
| Supprimer son propre fichier  | `403`    |

Deux surprises. `contentType` est ce que dit le client, et la règle ne regarde jamais à l’intérieur du fichier. Traitez-le donc comme une protection contre les erreurs, pas contre quelqu’un qui essaie. Si un fichier envoyé compte, vérifiez-le sur un serveur.

Et l’utilisateur ne pouvait plus supprimer ses propres fichiers. Une suppression n’a pas de `request.resource`, donc le contrôle tombe sur une valeur nulle, la règle plante et la requête est refusée. Le journal de l’émulateur montrait `Null value error` sur cette ligne. Séparez les opérations :

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

La suppression a alors renvoyé `204`, et le fichier de 2 Mo a toujours reçu `403`.

## Pourquoi `allow read` ne me laisse-t-il pas lister un dossier ?

`read` couvre `get` et `list`, donc je m’attendais à ce qu’un dossier public se liste. Cela dépendait du joker :

| Règle sur `public/`                     | Téléchargement | Liste du préfixe `public/` |
| --------------------------------------- | -------------- | -------------------------- |
| `match /public/{file}`, `allow read`    | `200`          | `403`                      |
| `match /public/{file=**}`, `allow read` | `200`          | `200`, 2 fichiers          |
| `match /public/{file=**}`, `allow get`  | `200`          | `403`                      |

Donc pour les ressources publiques, `allow get` sur un `match` récursif sert les fichiers et refuse de les énumérer. C’est ce que j’utiliserais pour tout ce que les gens ne doivent atteindre que par le lien exact.

## Comment limiter les fichiers aux membres d’une entreprise ?

Les règles Storage peuvent lire Firestore, avec `firestore.exists()` et `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 membre a reçu `200`, un utilisateur extérieur à l’entreprise `403`, et un invité aussi. Cela ne fait que déplacer la question vers qui peut écrire la collection `members`, c’est-à-dire de nouveau le [problème du rôle écrit par l’utilisateur](https://madsalt.tech/fr/blog/firebase-security-rules-examples/). Sur un vrai projet, Firebase [demande d’activer une autorisation](https://firebase.google.com/docs/rules/manage-deploy) reliant les deux produits, et chaque recherche [compte comme une lecture Firestore](https://firebase.google.com/docs/storage/security/rules-conditions). Je n’ai testé ni l’une ni l’autre dans l’émulateur.

## Comment vérifier votre bucket ?

- Cherchez dans votre base de données et votre code les URL `firebasestorage` enregistrées qui pointent vers des fichiers privés.
- Si le bucket a un jour été ouvert ou réservé aux utilisateurs connectés, remplacez ou révoquez les jetons de tout ce qui est sensible. Corriger les règles ne suffit pas.
- Essayez un second compte sur les fichiers du premier compte, dans l’[émulateur](https://firebase.google.com/docs/rules/insecure-rules) ou sur un projet de test.

Le [Vérificateur de règles Firebase](https://madsalt.tech/fr/tools/firebase-rules-checker/) gratuit accepte des règles Storage collées. Sur ces jeux de règles, il a signalé le mode test, les écritures réservées aux utilisateurs connectés et les lectures publiques. Il a laissé passer la règle réservée au propriétaire sans limite de taille ni de type, et il ne voit pas du tout les jetons de téléchargement, car aucun ne ressemble à une règle ouverte. Un résultat propre couvre donc le texte des règles, pas les fichiers.

**Limites.** Émulateur local sur des fichiers factices, via REST. Je n’ai pas testé Google Cloud IAM sur le bucket, la révocation de jeton dans la console, ni la façon dont un bucket de production sert un fichier HTML envoyé. La production peut différer de l’émulateur sur des détails que je n’ai pas vérifiés.

Les mêmes attaques côte à côte sur Supabase et Firebase sont dans [Supabase vs Firebase : sécurité](https://madsalt.tech/fr/blog/supabase-vs-firebase-security/).

À lire aussi: [Logiciel de gestion documentaire PME : 7 outils chiffrés](https://madsalt.tech/fr/blog/document-management-software-for-small-business/).

## Mon cas similaire

Une entreprise pour laquelle j'ai construit payait des milliers de dollars par mois pour un produit documentaire d'entreprise. Sa propre plateforme coûte maintenant quelques centaines par mois, avec des rôles pour les documents, les formulaires, les rapports et un portail client, et seulement les fonctions que l'équipe utilise. Voir le [cas de la plateforme documentaire de chantier](https://madsalt.tech/fr/work/construction-document-platform/).

Vous stockez des fichiers que personne ne voudrait voir partagés ? Écrivez-moi et nous déterminerons comment votre application doit les distribuer.

Vous stockez des fichiers qui ne doivent pas être partagés ?

Dites-moi ce que vous avez aujourd'hui et ce qu'il vous faut. Je vous répondrai avec l'option que je choisirais.

[Me contacter](https://madsalt.tech/fr/#contact)
