FB-rate limiting (Sicherheits-Regeln?

Den trick zu halten, ist eine Prüfung der letzten Zeit ein Benutzer eine Nachricht gepostet. Dann können Sie erzwingen, die Zeit, jede Nachricht gepostet wird, auf der Grundlage der audit-Wert:

{
  "rules": {
          //this stores the last message I sent so I can throttle them by timestamp
      "last_message": {
        "$user": {
          //timestamp can't be deleted or I could just recreate it to bypass our throttle
          ".write": "newData.exists() && auth.uid === $user",
          //the new value must be at least 5000 milliseconds after the last (no more than one message every five seconds)
          //the new value must be before now (it will be since `now` is when it reaches the server unless I try to cheat)
          ".validate": "newData.isNumber() && newData.val() === now && (!data.exists() || newData.val() > data.val()+5000)"
        }
      },

      "messages": {
        "$message_id": {
          //message must have a timestamp attribute and a sender attribute
          ".write": "newData.hasChildren(['timestamp', 'sender', 'message'])",
          "sender": {
            ".validate": "newData.val() === auth.uid"
          },
          "timestamp": {
            //in order to write a message, I must first make an entry in timestamp_index
            //additionally, that message must be within 500ms of now, which means I can't
            //just re-use the same one over and over, thus, we've effectively required messages
            //to be 5 seconds apart
            ".validate": "newData.val() >= now - 500 && newData.val() === data.parent().parent().parent().child('last_message/'+auth.uid).val()"
          },
          "message": {
            ".validate": "newData.isString() && newData.val().length < 500" 
          },
          "$other": {
            ".validate": false 
          }
        }
      } 
  }
}

Ihn in Aktion zu sehen in diesem fiddle. Hier ist der Kern von dem, was in der Geige:

var fb = new Firebase(URL);
var userId; //log in and store user.uid here

//run our create routine
createRecord(data, function (recordId, timestamp) {
   console.log('created record ' + recordId + ' at time ' + new Date(timestamp));
});

//updates the last_message/path and returns the current timestamp
function getTimestamp(next) {
    var ref = fb.child('last_message/' + userId);
    ref.set(Firebase.ServerValue.TIMESTAMP, function (err) {
        if (err) { console.error(err); }
        else {
            ref.once('value', function (snap) {
                next(snap.val());
            });
        }
    });
}

function createRecord(data, next) {
    getTimestamp(function (timestamp) {
        //add the new timestamp to the record data
        var data = {
          sender: userId,
          timestamp: timestamp,
          message: 'hello world'
        };

        var ref = fb.child('messages').push(data, function (err) {
            if (err) { console.error(err); }
            else {
               next(ref.name(), timestamp);
            }
        });
    })
}

Den vorhandenen Antworten verwenden Sie zwei Datenbank-updates: (1) markieren Sie ein timestamp, und (2) befestigen Sie die markierten timestamp in das tatsächliche schreiben. Kato Antwort erfordert 500ms Zeit-Fenster, während ChiNhan ist, erfordert die Erinnerung an die nächsten Schlüssel.

Es ist ein einfacher Weg, es zu tun in einer einzigen Datenbank-update. Die Idee ist zu schreiben mehrerer Werte in die Datenbank, wenn Sie mit der update() Methode. Die Sicherheits-Regeln überprüft die geschriebenen Werte so, dass das schreiben nicht mehr als die Quote. Die Quote ist definiert als ein paar Werte: quotaTimestamp und postCount. Der postCount ist die Anzahl der posts innerhalb von 1 minute von der quotaTimestamp. Die security-Regeln einfach ablehnt, den nächsten zu schreiben, wenn der postCount einen bestimmten Wert übersteigt. Der postCount wird zurückgesetzt, wenn die quotaTimestamp ist staler als 1 minute.

Hier ist, wie um eine neue Nachricht zu schreiben:

function postMessage(user, message) {
  const now = Date.now() + serverTimeOffset;
  if (!user.quotaTimestamp || user.quotaTimestamp + 60 * 1000 < now) {
    //Resets the quota when 1 minute has elapsed since the quotaTimestamp.
    user.quotaTimestamp = database.ServerValue.TIMESTAMP;
    user.postCount = 0;
  }
  user.postCount++;

  const values = {};
  const messageId = //generate unique id
  values[`users/${user.uid}/quotaTimestamp`] = user.quotaTimestamp;
  values[`users/${user.uid}/postCount`] = user.postCount;
  values[`messages/${messageId}`] = {
    sender: ...,
    message: ...,
    ...
  };
  return this.db.database.ref().update(values);
}

Der Sicherheitsregeln zu bewerten, zu begrenzen auf höchstens 5 posts pro minute:

{
  "rules": {
    "users": {
      "$uid": {
        ".read": "$uid === auth.uid",
        ".write": "$uid === auth.uid && newData.child('postCount').val() <= 5",
        "quotaTimestamp": {
          //Only allow updating quotaTimestamp if it's staler than 1 minute.
          ".validate": "
            newData.isNumber()
            && (newData.val() === now
              ? (data.val() + 60 * 1000 < now)
              : (data.val() == newData.val()))"
        },
        "postCount": {
          //Only allow postCount to be incremented by 1
          //or reset to 1 when the quotaTimestamp is being refreshed.
          ".validate": "
            newData.isNumber()
            && (data.exists()
              ? (data.val() + 1 === newData.val()
                || (newData.val() === 1
                    && newData.parent().child('quotaTimestamp').val() === now))
              : (newData.val() === 1))"
        },
        "$other": { ".validate": false }
      }
    },

    "messages": {
      ...
    }
  }
}

Hinweis: die serverTimeOffset sollte beibehalten werden, um zu vermeiden, clock-skew.