Evita regole insicure

Utilizza questa guida per comprendere le vulnerabilità comuni nelle configurazioni delle regole di sicurezza di Firebase, esaminare e proteggere meglio le tue regole e testare le modifiche prima di implementarle.

Se ricevi un avviso che i tuoi dati non sono adeguatamente protetti, rivedi questi errori comuni e aggiorna eventuali regole vulnerabili.

Accedi alle tue regole di sicurezza Firebase

Per visualizzare le regole esistenti, utilizza l'interfaccia a riga di comando di Firebase o la console di Firebase. Assicurati di modificare le tue regole utilizzando lo stesso metodo, in modo coerente, per evitare di sovrascrivere erroneamente gli aggiornamenti. Se non sei sicuro che le regole definite localmente riflettano gli aggiornamenti più recenti, la console di Firebase mostra sempre la versione distribuita più di recente delle regole di sicurezza di Firebase.

Per accedere alle tue regole dalla console Firebase , seleziona il tuo progetto, quindi vai a Realtime Database , Cloud Firestore o Storage . Fai clic su Regole una volta che ti trovi nel database o nel bucket di archiviazione corretto.

Per accedere alle tue regole dall'interfaccia a riga di comando di Firebase, vai al file delle regole annotato nel tuo file firebase.json .

Comprendere le regole di sicurezza di Firebase

Le regole di sicurezza di Firebase proteggono i tuoi dati da utenti malintenzionati. Quando crei un'istanza di database o un bucket Cloud Storage nella console Firebase, puoi scegliere di negare l'accesso a tutti gli utenti ( Modalità bloccata ) o concedere l'accesso a tutti gli utenti ( Modalità test ). Anche se potresti volere una configurazione più aperta durante lo sviluppo, assicurati di dedicare del tempo a configurare correttamente le tue regole e proteggere i tuoi dati prima di distribuire la tua app.

Mentre sviluppi la tua app e test diverse configurazioni per le tue regole, utilizza uno degli emulatori Firebase locali per eseguire la tua app in un ambiente di sviluppo locale.

Scenari comuni con regole non sicure

Le regole che potresti aver impostato per impostazione predefinita o quando hai lavorato inizialmente allo sviluppo della tua app dovrebbero essere riviste e aggiornate prima di distribuire la tua app. Assicurati di proteggere adeguatamente i dati dei tuoi utenti evitando le seguenti insidie ​​comuni.

Accesso libero

Durante la configurazione del progetto Firebase, potresti aver impostato le regole per consentire l'accesso aperto durante lo sviluppo. Potresti pensare di essere l'unica persona che utilizza la tua app, ma se l'hai distribuita, è disponibile su Internet. Se non stai autenticando gli utenti e configurando le regole di sicurezza, chiunque indovini l'ID del tuo progetto può rubare, modificare o eliminare i dati.

// Allow read/write access to all users under any conditions
// Warning: **NEVER** use this ruleset in production; it allows
// anyone to overwrite your entire database.

service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if true;
    }
  }
}

{
  // Allow read/write access to all users under any conditions
  // Warning: **NEVER** use this ruleset in production; it allows
  // anyone to overwrite your entire database.

  "rules": {
    ".read": true,
    ".write": true
  }
}
    

// Anyone can read or write to the bucket, even non-users of your app.
// Because it is shared with App Engine, this will also make
// files uploaded via App Engine public.
// Warning: This rule makes every file in your Cloud Storage bucket accessible to any user.
// Apply caution before using it in production, since it means anyone
// can overwrite all your files.

service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read, write;
    }
  }
}
    

service cloud.firestore {
  match /databases/{database}/documents {
    // Allow only authenticated content owners access
    match /some_collection/{document} {
      allow read, write: if request.auth != null && request.auth.uid == request.resource.data.author_uid
    }
  }
}
  

service cloud.firestore {
  match /databases/{database}/documents {
    // Allow public read access, but only content owners can write
    match /some_collection/{document} {
      allow read: if true
      allow write: if request.auth != null && request.auth.uid == request.resource.data.author_uid
    }
  }
}
  

{
  "rules": {
    "some_path": {
      "$uid": {
        // Allow only authenticated content owners access to their data
        ".read": "auth !== null && auth.uid === $uid",
        ".write": "auth !== null && auth.uid === $uid"
      }
    }
  }
}
    

{
  // Allow anyone to read data, but only authenticated content owners can
  // make changes to their data

  "rules": {
    "some_path/$uid": {
      ".read": true,
      // or ".read": "auth.uid !== null" for only authenticated users
      ".write": "auth.uid === $uid"
    }
  }
}
    

// Grants a user access to a node matching their user ID
service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/path/to/file.txt"
    match /user/{userId}/{allPaths=**} {
      allow read, write: if request.auth.uid == userId;
    }
  }
}

service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/path/to/file.txt"
    match /user/{userId}/{allPaths=**} {
      allow read;
      allow write: if request.auth.uid == userId;
    }
  }
}
  

Accesso per qualsiasi utente autenticato

A volte, le regole controllano che un utente abbia effettuato l'accesso, ma non limitano ulteriormente l'accesso in base a tale autenticazione. Se una delle tue regole include auth != null , conferma che desideri che qualsiasi utente che ha effettuato l'accesso abbia accesso ai dati.

service cloud.firestore {
  match /databases/{database}/documents {
    match /some_collection/{document} {
      allow read, write: if request.auth.uid != null;
    }
  }
}

{
  "rules": {
    ".read": "auth.uid !== null",
    ".write": "auth.uid !== null"
  }
}

// Only authenticated users can read or write to the bucket
service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read, write: if request.auth != null;
    }
  }
}

service cloud.firestore {
  match /databases/{database}/documents {
    // Assign roles to all users and refine access based on user roles
    match /some_collection/{document} {
     allow read: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.role == "Reader"
     allow write: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.role == "Writer"

     // Note: Checking for roles in your database using `get` (as in the code
     // above) or `exists` carry standard charges for read operations.
    }
  }
}

// Give each user in your database a particular attribute
// and set it to true/false
// Then, use that attribute to grant access to subsets of data
// For example, an "admin" attribute set
// to "true" grants write access to data

service cloud.firestore {
  match /databases/{database}/documents {
    match /collection/{document} {
      allow write: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.admin == true;
      allow read: true;
    }
  }
}
  

service cloud.firestore {
  match /databases/{database}/documents {
    // Allow public read access, but only content owners can write
    match /some_collection/{document} {
      allow read: if true
      allow write: if request.auth.uid == request.resource.data.author_uid
    }
  }
}
  

{
  "rules": {
    "some_path": {
      "$uid": {
        // Allow only authenticated content owners access to their data
        ".read": "auth.uid === $uid",
        ".write": "auth.uid === $uid"
      }
    }
  }
}
    

{
  "rules": {
    "some_path/$uid": {
      ".write": "auth.uid === $uid",
      // Create a "public" subpath in your dataset
      "public": {
        ".read": true
        // or ".read": "auth.uid !== null"
      },
      // Create a "private" subpath in your dataset
      "private": {
        ".read": "auth.uid === $uid"
      }
    }
  }
}
    

{
  // Allow anyone to read data, but only authenticated content owners can
  // make changes to their data

  "rules": {
    "some_path/$uid": {
      ".read": true,
      // or ".read": "auth.uid !== null" for only authenticated users
      ".write": "auth.uid === $uid"
    }
  }
}
    

// Allow reads if the group ID in your token matches the file metadata's `owner` property
// Allow writes if the group ID is in the user's custom token
match /files/{groupId}/{fileName} {
  allow read: if resource.metadata.owner == request.auth.token.groupId;
  allow write: if request.auth.token.groupId == groupId;
}

// Grants a user access to a node matching their user ID
service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/path/to/file.txt"
    match /user/{userId}/{allPaths=**} {
      allow read, write: if request.auth.uid == userId;
    }
  }
}

service firebase.storage {
  match /b/{bucket}/o {
    // Files look like: "user/<UID>/path/to/file.txt"
    match /user/{userId}/{allPaths=**} {
      allow read;
      allow write: if request.auth.uid == userId;
    }
  }
}
  

(Realtime Database) Regole ereditate in modo errato

Regole di sicurezza del database in tempo reale a cascata, con regole nei percorsi padre più superficiali che sovrascrivono le regole nei nodi figlio più profondi. Quando scrivi una regola su un nodo figlio, ricorda che può concedere solo privilegi aggiuntivi. Non è possibile perfezionare o revocare l'accesso ai dati in un percorso più profondo nel database.

{
  "rules": {
     "foo": {
        // allows read to /foo/*
        ".read": "data.child('baz').val() === true",
        "bar": {
          /* ignored, since read was allowed already */
          ".read": false
        }
     }
  }
}

Accesso chiuso

Durante lo sviluppo della tua app, un altro approccio comune consiste nel mantenere i tuoi dati bloccati. In genere, questo significa che hai chiuso l'accesso in lettura e scrittura a tutti gli utenti, come segue:

// Deny read/write access to all users under any conditions
service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if false;
    }
  }
}

{
  "rules": {
    ".read": false,
    ".write": false
  }
}
    

// Access to files through Cloud Storage is completely disallowed.
// Files may still be accessible through App Engine or Google Cloud Storage APIs.

service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
      allow read, write: if false;
    }
  }
}

Gli SDK Firebase Admin e le funzioni cloud possono ancora accedere al tuo database. Utilizza queste regole quando intendi utilizzare Cloud Firestore o Realtime Database come back-end solo server insieme a Firebase Admin SDK. Sebbene sia sicuro, dovresti verificare che i client della tua app possano recuperare correttamente i dati.

Scopri di più sulle regole di sicurezza di Cloud Firestore e su come funzionano in Introduzione alle regole di sicurezza di Cloud Firestore .

Testa le regole di sicurezza di Cloud Firestore

Per controllare il comportamento della tua app e verificare le configurazioni delle regole di sicurezza di Cloud Firestore, utilizza l' emulatore Firebase . Utilizza l'emulatore Cloud Firestore per eseguire e automatizzare gli unit test in un ambiente locale prima di distribuire eventuali modifiche.

Per convalidare rapidamente le regole di sicurezza Firebase nella console Firebase, utilizza Firebase Rules Simulator .