Ikuti sorotan dari Firebase di Google I/O 2023. Pelajari lebih lanjut

Menghindari aturan yang tidak aman

Gunakan panduan ini untuk memahami kerentanan umum pada konfigurasi Aturan Keamanan Firebase, meninjau dan mengamankan aturan Anda sendiri dengan lebih baik, dan menguji perubahan yang Anda buat sebelum men-deploy-nya.

Jika Anda menerima peringatan bahwa data Anda tidak diamankan dengan baik, tinjau error yang umum terjadi ini dan perbarui aturan yang rentan.

Mengakses Aturan Keamanan Firebase

Untuk melihat Aturan yang sudah ada, gunakan Firebase CLI atau Firebase console. Pastikan Anda mengedit aturan menggunakan metode yang sama secara konsisten, agar tidak ada pembaruan yang tumpang tindih secara tidak sengaja. Jika Anda tidak yakin bahwa aturan yang ditentukan secara lokal mencerminkan pembaruan terkini, Firebase console selalu menunjukkan versi Aturan Keamanan Firebase yang paling baru di-deploy.

Untuk mengakses aturan Anda dari Firebase console, pilih project, kemudian buka Realtime Database, Cloud Firestore, atau Storage. Klik Aturan setelah Anda berada di database atau bucket penyimpanan yang tepat.

Untuk mengakses aturan dari Firebase CLI, buka file aturan yang tercantum pada file firebase.json Anda.

Memahami Aturan Keamanan Firebase

Aturan Keamanan Firebase melindungi data Anda dari pengguna yang bermaksud jahat. Saat membuat instance database atau bucket Cloud Storage di Firebase console, Anda dapat memilih untuk menolak akses ke semua pengguna (Mode terkunci) atau memberikan akses ke semua pengguna (Mode pengujian). Meskipun Anda mungkin menginginkan konfigurasi yang lebih terbuka selama pengembangan, pastikan Anda mengonfigurasi aturan dan mengamankan data Anda dengan benar sebelum men-deploy aplikasi.

Saat Anda mengembangkan aplikasi dan menguji berbagai konfigurasi untuk aturan Anda, gunakan salah satu emulator Firebase lokal untuk menjalankan aplikasi Anda di lingkungan pengembangan lokal.

Skenario umum mengenai aturan yang tidak aman

Aturan yang mungkin telah Anda siapkan secara default atau saat Anda mulai mengembangkan aplikasi harus ditinjau dan diperbarui sebelum men-deploy aplikasi. Pastikan Anda mengamankan data pengguna dengan benar dengan menghindari kesalahan umum berikut.

Akses terbuka

Ketika menyiapkan project Firebase, Anda mungkin telah menetapkan aturan yang mengizinkan akses terbuka selama pengembangan. Anda mungkin berpikir bahwa Anda adalah satu-satunya orang yang menggunakan aplikasi, tetapi jika Anda telah men-deploy-nya, aplikasi tersebut akan tersedia di internet. Jika Anda tidak mengautentikasi pengguna dan mengonfigurasi aturan keamanan, maka siapa saja yang dapat menebak project ID Anda dapat mencuri, memodifikasi, atau menghapus data.

Tidak disarankan: Akses baca dan tulis untuk semua pengguna.

Cloud Firestore

// 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;
    }
  }
}

Realtime Database

{
  // 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
  }
}

Cloud Storage

// 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;
    }
  }
}

Solusi: Aturan yang membatasi akses baca dan tulis.

Buat aturan yang sesuai untuk hierarki data Anda. Salah satu solusi yang umum untuk ketidakamanan ini adalah keamanan berbasis pengguna dengan Firebase Authentication. Pelajari lebih lanjut cara mengautentikasi pengguna dengan aturan.

Cloud Firestore

Khusus pemilik konten

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
    }
  }
}

Akses publik dan pribadi campuran

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
    }
  }
}

Realtime Database

Khusus pemilik konten

{
  "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"
      }
    }
  }
}

Akses publik dan pribadi campuran

{
  // 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"
    }
  }
}

Cloud Storage

Khusus pemilik konten

// 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;
    }
  }
}

Akses publik dan pribadi campuran

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;
    }
  }
}

Akses untuk setiap pengguna yang diautentikasi

Terkadang, Aturan memastikan apakah pengguna sudah login, tetapi tidak membatasi akses lebih lanjut berdasarkan autentikasi tersebut. Jika salah satu aturan Anda menyertakan auth != null, konfirmasikan bahwa Anda ingin setiap pengguna yang login memiliki akses ke data.

Tidak direkomendasikan: Setiap pengguna yang login memiliki akses baca dan tulis ke seluruh database Anda.

Cloud Firestore

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

Realtime Database

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

Cloud Storage

// 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;
    }
  }
}

Solusi: Persempit akses menggunakan kondisi keamanan.

Saat memeriksa autentikasi, Anda juga dapat menggunakan salah satu properti autentikasi untuk membatasi akses lebih lanjut bagi pengguna tertentu ke set data tertentu. Pelajari lebih lanjut berbagai properti autentikasi.

Cloud Firestore

Akses berbasis peran

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

Akses berbasis atribut

// 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;
    }
  }
}

Akses publik dan pribadi campuran

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
    }
  }
}

Realtime Database

Khusus pemilik konten

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

Akses yang ditentukan oleh jalur

{
  "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"
      }
    }
  }
}

Akses publik dan pribadi campuran

{
  // 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"
    }
  }
}

Cloud Storage

Akses berbasis grup

// 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;
}

Khusus pemilik konten

// 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;
    }
  }
}

Akses publik dan pribadi campuran

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) Aturan yang diturunkan dengan tidak semestinya

Aturan Keamanan Realtime Database bersifat menurun, yaitu aturan di jalur induk yang lebih dangkal akan mengganti aturan di node turunan yang lebih dalam. Saat Anda menulis aturan di node turunan, ingat bahwa node tersebut hanya dapat memberikan hak istimewa tambahan. Anda tidak dapat memperbaiki atau mencabut akses ke data di jalur yang lebih dalam di database Anda.

Tidak direkomendasikan: Memperbaiki aturan di jalur turunan

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

Solusi: Tuliskan aturan di jalur induk yang luas dan berikan lebih banyak hak istimewa di jalur turunan. Jika kebutuhan akses data Anda memerlukan lebih banyak perincian, pertahankan aturan Anda secara terperinci. Pelajari lebih lanjut Aturan Keamanan Realtime Database menurun di artikel Mengamankan Data.

Akses tertutup

Saat Anda mengembangkan aplikasi, pendekatan umum lainnya adalah menjaga data Anda tetap terkunci. Biasanya, ini berarti Anda menutup akses baca dan tulis untuk semua pengguna, seperti berikut ini:

Cloud Firestore

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

Realtime Database

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

Cloud Storage

// 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;
    }
  }
}

Firebase Admin SDK dan Cloud Functions masih dapat mengakses database Anda. Gunakan aturan ini jika Anda ingin menggunakan Cloud Firestore atau Realtime Database sebagai backend khusus server melengkapi Firebase Admin SDK. Meskipun aman, Anda harus menguji apakah klien aplikasi Anda dapat mengambil data dengan benar.

Pelajari lebih lanjut Aturan Keamanan Cloud Firestore dan cara kerjanya di bagian Memulai Aturan Keamanan Cloud Firestore.

Menguji Aturan Keamanan Cloud Firestore

Untuk memeriksa perilaku aplikasi dan memverifikasi konfigurasi Aturan Keamanan Cloud Firestore Anda, gunakan Emulator Firebase. Gunakan emulator Cloud Firestore untuk menjalankan dan mengotomatiskan pengujian unit di lingkungan lokal sebelum Anda men-deploy perubahan.

Untuk memvalidasi Aturan Keamanan Firebase dengan cepat di Firebase console, gunakan Simulator Aturan Firebase.