Gerçek Zamanlı Veritabanı Güvenliği Kurallarındaki koşulları kullanın

Bu kılavuz, Firebase Gerçek Zamanlı Veritabanı Güvenlik Kurallarınıza koşulların nasıl ekleneceğini göstermek için temel Firebase Güvenlik Kuralları dil kılavuzunu temel alır.

Gerçek Zamanlı Veritabanı Güvenliği Kurallarının birincil yapı taşı koşuldur . Koşul, belirli bir işleme izin verilmesi veya reddedilmesi gerektiğini belirleyen bir Boolean ifadesidir. Temel kurallar için, koşullar olarak true ve false değerlerin kullanılması son derece iyi sonuç verir. Ancak Gerçek Zamanlı Veritabanı Güvenliği Kuralları dili size aşağıdakileri yapabilecek daha karmaşık koşullar yazmanın yollarını sunar:

• Kullanıcı kimlik doğrulamasını kontrol edin
• Mevcut verileri yeni gönderilen verilere göre değerlendirin
• Veritabanınızın farklı bölümlerine erişin ve bunları karşılaştırın
• Gelen verileri doğrula
• Güvenlik mantığı için gelen sorguların yapısını kullanın

Yol Segmentlerini Yakalamak için $ Değişkenlerini Kullanma

Yakalama değişkenlerini $ önekiyle bildirerek, okuma veya yazma için yolun bölümlerini yakalayabilirsiniz. Bu bir joker karakter görevi görür ve kural koşullarında kullanılmak üzere o anahtarın değerini saklar:

{
  "rules": {
    "rooms": {
      // this rule applies to any child of /rooms/, the key for each room id
      // is stored inside $room_id variable for reference
      "$room_id": {
        "topic": {
          // the room's topic can be changed if the room id has "public" in it
          ".write": "$room_id.contains('public')"
        }
      }
    }
  }
}

Dinamik $ değişkenleri sabit yol adlarıyla paralel olarak da kullanılabilir. Bu örnekte, widget title ve color dışında hiçbir alt öğeye sahip olmamasını sağlayan bir .validate kuralını bildirmek için $other değişkenini kullanıyoruz. Ek alt öğelerin oluşturulmasına neden olacak herhangi bir yazma işlemi başarısız olur.

{
  "rules": {
    "widget": {
      // a widget can have a title or color attribute
      "title": { ".validate": true },
      "color": { ".validate": true },

      // but no other child paths are allowed
      // in this case, $other means any key excluding "title" and "color"
      "$other": { ".validate": false }
    }
  }
}

Kimlik doğrulama

En yaygın güvenlik kuralı modellerinden biri, kullanıcının kimlik doğrulama durumuna göre erişimin kontrol edilmesidir. Örneğin, uygulamanız yalnızca oturum açmış kullanıcıların veri yazmasına izin vermek isteyebilir.

Uygulamanız Firebase Kimlik Doğrulaması kullanıyorsa request.auth değişkeni, veri isteyen istemcinin kimlik doğrulama bilgilerini içerir. request.auth hakkında daha fazla bilgi için başvuru belgelerine bakın.

Firebase Authentication, Firebase Gerçek Zamanlı Veritabanı ile entegre olarak koşulları kullanarak veri erişimini kullanıcı bazında kontrol etmenize olanak tanır. Bir kullanıcının kimliği doğrulandıktan sonra, Gerçek Zamanlı Veritabanı Güvenliği Kuralları kurallarınızdaki auth değişkeni kullanıcının bilgileriyle doldurulacaktır. Bu bilgiler, benzersiz tanımlayıcıların ( uid ) yanı sıra Facebook kimliği veya e-posta adresi gibi bağlantılı hesap verilerini ve diğer bilgileri içerir. Özel bir kimlik doğrulama sağlayıcısı uygularsanız kullanıcınızın kimlik doğrulama verisine kendi alanlarınızı ekleyebilirsiniz.

Bu bölümde Firebase Gerçek Zamanlı Veritabanı Güvenlik Kuralları dilinin kullanıcılarınıza ilişkin kimlik doğrulama bilgileriyle nasıl birleştirileceği açıklanmaktadır. Bu iki kavramı birleştirerek verilere erişimi kullanıcı kimliğine göre kontrol edebilirsiniz.

auth Doğrulama Değişkeni

Kurallardaki önceden tanımlanmış auth değişkeni, kimlik doğrulama gerçekleşmeden önce boştur.

Bir kullanıcının kimliği Firebase Authentication ile doğrulandıktan sonra aşağıdaki özellikleri içerecektir:

Her kullanıcının yalnızca kullanıcıya özel bir yola yazabilmesini sağlamak için auth değişkenini kullanan örnek bir kural aşağıda verilmiştir:

{
  "rules": {
    "users": {
      "$user_id": {
        // grants write access to the owner of this user account
        // whose uid must exactly match the key ($user_id)
        ".write": "$user_id === auth.uid"
      }
    }
  }
}

Veritabanınızı Kimlik Doğrulama Koşullarını Destekleyecek Şekilde Yapılandırma

Veritabanınızı Kural yazmayı kolaylaştıracak şekilde yapılandırmak genellikle yararlı olur. Kullanıcı verilerini Gerçek Zamanlı Veritabanında depolamaya yönelik yaygın bir model, tüm kullanıcılarınızı, çocukları her kullanıcının uid değerleri olan tek bir users düğümünde depolamaktır. Bu verilere erişimi, yalnızca oturum açmış kullanıcının kendi verilerini görebileceği şekilde kısıtlamak istiyorsanız, kurallarınız buna benzer olacaktır.

{
  "rules": {
    "users": {
      "$uid": {
        ".read": "auth !== null && auth.uid === $uid"
      }
    }
  }
}

Kimlik Doğrulama Özel Talepleriyle Çalışma

Farklı kullanıcılar için özel erişim kontrolü gerektiren uygulamalarda Firebase Authentication, geliştiricilerin bir Firebase kullanıcısı üzerinde hak talepleri belirlemesine olanak tanır. Bu taleplere kurallarınızdaki auth.token değişkeninden erişilebilir. hasEmergencyTowel özel talebinden yararlanan kurallara bir örnek:

{
  "rules": {
    "frood": {
      // A towel is about the most massively useful thing an interstellar
      // hitchhiker can have
      ".read": "auth.token.hasEmergencyTowel === true"
    }
  }
}

Kendi özel kimlik doğrulama belirteçlerini oluşturan geliştiriciler, isteğe bağlı olarak bu belirteçlere hak talepleri ekleyebilir. Bu talepler, kurallarınızdaki auth.token değişkeninde mevcuttur.

Mevcut Veriler ve Yeni Veriler

Önceden tanımlanmış data değişkeni, bir yazma işlemi gerçekleşmeden önce verilere başvurmak için kullanılır. Bunun tersine, newData değişkeni, yazma işleminin başarılı olması durumunda mevcut olacak yeni verileri içerir. newData yazılmakta olan yeni verilerle mevcut verilerin birleştirilmiş sonucunu temsil eder.

Örneklendirmek gerekirse, bu kural yeni kayıtlar oluşturmamıza veya mevcut kayıtları silmemize izin verir, ancak mevcut boş olmayan verilerde değişiklik yapmamıza izin vermez:

// we can write as long as old data or new data does not exist
// in other words, if this is a delete or a create, but not an update
".write": "!data.exists() || !newData.exists()"

Diğer Yollardaki Verilere Referans Verme

Herhangi bir veri kurallar için kriter olarak kullanılabilir. Önceden tanımlanmış root , data ve newData değişkenlerini kullanarak, write olayından önce veya sonra var olan herhangi bir yola erişebiliriz.

/allow_writes/ düğümünün değeri true olduğu, üst düğümün readOnly bayrağı seti olmadığı ve yeni yazılan verilerde foo adında bir alt öğe olduğu sürece yazma işlemlerine izin veren bu örneği düşünün:

".write": "root.child('allow_writes').val() === true &&
          !data.parent().child('readOnly').exists() &&
          newData.child('foo').exists()"

Verileri Doğrulama

Veri yapılarını uygulamak ve verilerin biçimini ve içeriğini doğrulamak, yalnızca bir .write kuralının erişim izni vermeyi başarmasından sonra çalıştırılan .validate kuralları kullanılarak yapılmalıdır. Aşağıda, yalnızca 1900-2099 yılları arasındaki YYYY-AA-GG biçimindeki tarihlere izin veren ve normal ifade kullanılarak kontrol edilen örnek bir .validate kural tanımı verilmiştir.

".validate": "newData.isString() &&
              newData.val().matches(/^(19|20)[0-9][0-9][-\\/. ](0[1-9]|1[012])[-\\/. ](0[1-9]|[12][0-9]|3[01])$/)"

.validate kuralları, basamaklanmayan tek güvenlik kuralı türüdür. Herhangi bir alt kayıtta herhangi bir doğrulama kuralı başarısız olursa yazma işleminin tamamı reddedilir. Ayrıca, veriler silindiğinde (yani, yazılan yeni değer null olduğunda) doğrulama tanımları yoksayılır.

Bunlar önemsiz noktalar gibi görünebilir ancak aslında güçlü Firebase Gerçek Zamanlı Veritabanı Güvenlik Kuralları yazmak için önemli özelliklerdir. Aşağıdaki kuralları göz önünde bulundurun:

{
  "rules": {
    // write is allowed for all paths
    ".write": true,
    "widget": {
      // a valid widget must have attributes "color" and "size"
      // allows deleting widgets (since .validate is not applied to delete rules)
      ".validate": "newData.hasChildren(['color', 'size'])",
      "size": {
        // the value of "size" must be a number between 0 and 99
        ".validate": "newData.isNumber() &&
                      newData.val() >= 0 &&
                      newData.val() <= 99"
      },
      "color": {
        // the value of "color" must exist as a key in our mythical
        // /valid_colors/ index
        ".validate": "root.child('valid_colors/' + newData.val()).exists()"
      }
    }
  }
}

Bu değişkeni göz önünde bulundurarak aşağıdaki yazma işlemlerinin sonuçlarına bakın:

var ref = db.ref("/widget");

// PERMISSION_DENIED: does not have children color and size
ref.set('foo');

// PERMISSION DENIED: does not have child color
ref.set({size: 22});

// PERMISSION_DENIED: size is not a number
ref.set({ size: 'foo', color: 'red' });

// SUCCESS (assuming 'blue' appears in our colors list)
ref.set({ size: 21, color: 'blue'});

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child('size').set(99);

FIRDatabaseReference *ref = [[[FIRDatabase database] reference] child: @"widget"];

// PERMISSION_DENIED: does not have children color and size
[ref setValue: @"foo"];

// PERMISSION DENIED: does not have child color
[ref setValue: @{ @"size": @"foo" }];

// PERMISSION_DENIED: size is not a number
[ref setValue: @{ @"size": @"foo", @"color": @"red" }];

// SUCCESS (assuming 'blue' appears in our colors list)
[ref setValue: @{ @"size": @21, @"color": @"blue" }];

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
[[ref child:@"size"] setValue: @99];

var ref = FIRDatabase.database().reference().child("widget")

// PERMISSION_DENIED: does not have children color and size
ref.setValue("foo")

// PERMISSION DENIED: does not have child color
ref.setValue(["size": "foo"])

// PERMISSION_DENIED: size is not a number
ref.setValue(["size": "foo", "color": "red"])

// SUCCESS (assuming 'blue' appears in our colors list)
ref.setValue(["size": 21, "color": "blue"])

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child("size").setValue(99);

FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("widget");

// PERMISSION_DENIED: does not have children color and size
ref.setValue("foo");

// PERMISSION DENIED: does not have child color
ref.child("size").setValue(22);

// PERMISSION_DENIED: size is not a number
Map<String,Object> map = new HashMap<String, Object>();
map.put("size","foo");
map.put("color","red");
ref.setValue(map);

// SUCCESS (assuming 'blue' appears in our colors list)
map = new HashMap<String, Object>();
map.put("size", 21);
map.put("color","blue");
ref.setValue(map);

// If the record already exists and has a color, this will
// succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
// will fail to validate
ref.child("size").setValue(99);

# PERMISSION_DENIED: does not have children color and size
curl -X PUT -d 'foo' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# PERMISSION DENIED: does not have child color
curl -X PUT -d '{"size": 22}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# PERMISSION_DENIED: size is not a number
curl -X PUT -d '{"size": "foo", "color": "red"}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# SUCCESS (assuming 'blue' appears in our colors list)
curl -X PUT -d '{"size": 21, "color": "blue"}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# If the record already exists and has a color, this will
# succeed, otherwise it will fail since newData.hasChildren(['color', 'size'])
# will fail to validate
curl -X PUT -d '99' \
https://docs-examples.firebaseio.com/rest/securing-data/example/size.json

Şimdi aynı yapıya bakalım, ancak .validate yerine .write kurallarını kullanalım:

{
  "rules": {
    // this variant will NOT allow deleting records (since .write would be disallowed)
    "widget": {
      // a widget must have 'color' and 'size' in order to be written to this path
      ".write": "newData.hasChildren(['color', 'size'])",
      "size": {
        // the value of "size" must be a number between 0 and 99, ONLY IF WE WRITE DIRECTLY TO SIZE
        ".write": "newData.isNumber() && newData.val() >= 0 && newData.val() <= 99"
      },
      "color": {
        // the value of "color" must exist as a key in our mythical valid_colors/ index
        // BUT ONLY IF WE WRITE DIRECTLY TO COLOR
        ".write": "root.child('valid_colors/'+newData.val()).exists()"
      }
    }
  }
}

Bu varyantta aşağıdaki işlemlerden herhangi biri başarılı olacaktır:

var ref = new Firebase(URL + "/widget");

// ALLOWED? Even though size is invalid, widget has children color and size,
// so write is allowed and the .write rule under color is ignored
ref.set({size: 99999, color: 'red'});

// ALLOWED? Works even if widget does not exist, allowing us to create a widget
// which is invalid and does not have a valid color.
// (allowed by the write rule under "color")
ref.child('size').set(99);

Firebase *ref = [[Firebase alloc] initWithUrl:URL];

// ALLOWED? Even though size is invalid, widget has children color and size,
// so write is allowed and the .write rule under color is ignored
[ref setValue: @{ @"size": @9999, @"color": @"red" }];

// ALLOWED? Works even if widget does not exist, allowing us to create a widget
// which is invalid and does not have a valid color.
// (allowed by the write rule under "color")
[[ref childByAppendingPath:@"size"] setValue: @99];

var ref = Firebase(url:URL)

// ALLOWED? Even though size is invalid, widget has children color and size,
// so write is allowed and the .write rule under color is ignored
ref.setValue(["size": 9999, "color": "red"])

// ALLOWED? Works even if widget does not exist, allowing us to create a widget
// which is invalid and does not have a valid color.
// (allowed by the write rule under "color")
ref.childByAppendingPath("size").setValue(99)

Firebase ref = new Firebase(URL + "/widget");

// ALLOWED? Even though size is invalid, widget has children color and size,
// so write is allowed and the .write rule under color is ignored
Map<String,Object> map = new HashMap<String, Object>();
map.put("size", 99999);
map.put("color", "red");
ref.setValue(map);

// ALLOWED? Works even if widget does not exist, allowing us to create a widget
// which is invalid and does not have a valid color.
// (allowed by the write rule under "color")
ref.child("size").setValue(99);

# ALLOWED? Even though size is invalid, widget has children color and size,
# so write is allowed and the .write rule under color is ignored
curl -X PUT -d '{size: 99999, color: "red"}' \
https://docs-examples.firebaseio.com/rest/securing-data/example.json

# ALLOWED? Works even if widget does not exist, allowing us to create a widget
# which is invalid and does not have a valid color.
# (allowed by the write rule under "color")
curl -X PUT -d '99' \
https://docs-examples.firebaseio.com/rest/securing-data/example/size.json

Bu, .write ve .validate kuralları arasındaki farkları gösterir. Gösterildiği gibi, silme işlemlerine izin verilip verilmeyeceğine bağlı olan newData.hasChildren() kuralının olası istisnası dışında, bu kuralların tümü .validate kullanılarak yazılmalıdır.

Sorgu Tabanlı Kurallar

Kuralları filtre olarak kullanamasanız da kurallarınızdaki sorgu parametrelerini kullanarak veri alt kümelerine erişimi sınırlayabilirsiniz. query. Sorgu parametrelerine göre okuma veya yazma erişimi vermek için kurallarınızdaki ifadeleri kullanın.

Örneğin, aşağıdaki sorgu tabanlı kural, baskets koleksiyonundaki verilere erişimi yalnızca etkin kullanıcının sahip olduğu alışveriş sepetleriyle kısıtlamak için kullanıcı tabanlı güvenlik kurallarını ve sorgu tabanlı kuralları kullanır:

"baskets": {
  ".read": "auth.uid !== null &&
            query.orderByChild === 'owner' &&
            query.equalTo === auth.uid" // restrict basket access to owner of basket
}

Kuraldaki sorgu parametrelerini içeren aşağıdaki sorgu başarılı olacaktır:

db.ref("baskets").orderByChild("owner")
                 .equalTo(auth.currentUser.uid)
                 .on("value", cb)                 // Would succeed

Ancak kuraldaki parametreleri içermeyen sorgular PermissionDenied hatasıyla başarısız olur:

db.ref("baskets").on("value", cb)                 // Would fail with PermissionDenied

Bir istemcinin okuma işlemleri aracılığıyla indirdiği veri miktarını sınırlamak için sorgu tabanlı kuralları da kullanabilirsiniz.

Örneğin, aşağıdaki kural okuma erişimini öncelik sırasına göre bir sorgunun yalnızca ilk 1000 sonucuyla sınırlandırır:

messages: {
  ".read": "query.orderByKey &&
            query.limitToFirst <= 1000"
}

// Example queries:

db.ref("messages").on("value", cb)                // Would fail with PermissionDenied

db.ref("messages").limitToFirst(1000)
                  .on("value", cb)                // Would succeed (default order by key)

Aşağıdaki query. ifadeler Gerçek Zamanlı Veritabanı Güvenlik Kurallarında mevcuttur.

Sonraki adımlar

Koşullarla ilgili bu tartışmanın ardından Kurallar hakkında daha kapsamlı bir anlayışa sahip olursunuz ve şunları yapmaya hazırsınız:

Temel kullanım durumlarını nasıl ele alacağınızı öğrenin ve Kuralları geliştirmeye, test etmeye ve dağıtmaya yönelik iş akışını öğrenin:

• Koşulları oluşturmak için kullanabileceğiniz önceden tanımlanmış Kural değişkenlerinin tamamı hakkında bilgi edinin.
• Yaygın senaryolara yönelik kurallar yazın.
• Güvenli olmayan Kuralları tespit etmeniz ve bunlardan kaçınmanız gereken durumları gözden geçirerek bilginizi geliştirin.
• Firebase Local Emulator Suite hakkında bilgi edinin ve bunu Kuralları test etmek için nasıl kullanabileceğinizi öğrenin.
• Kuralları dağıtmak için mevcut yöntemleri inceleyin.

Gerçek Zamanlı Veritabanına özel Kuralları Öğrenin özellikleri:

• Gerçek Zamanlı Veritabanınızı nasıl dizine ekleyeceğinizi öğrenin.
• Kuralları dağıtmak için REST API'yi inceleyin.