Walk your game with an exploiter's checklist — every remote, every trust boundary, every free-typed value — and harden each gap before you ship.
You've stacked the wall brick by brick: rate limiting paces the flood, server authority owns the numbers, input validation double-checks the text. But a wall only holds if every brick is in place — and the bricks are spread across your whole game, not one . A security audit is a deliberate walk through the finished game looking for missing bricks, with an exploiter's eyes, before an exploiter finds them for you. No new features. Just a checklist and fresh eyes.
Every place your server code accepts a value from a client is a trust boundary — a spot where a forged request could reach real logic. The auditor's first job is to make a map of every boundary. Every FireServer in a LocalScript is one; the matching OnServerEvent handler on the server is where it meets your code.
That means the audit starts as a search, not an inspection: find every remote in your game (search for FireServer( and OnServerEvent), pair each call with its handler, and add it to your list. Most small games end up with a dozen or fewer boundaries. Your whole audit is checking each one against the same three questions.
You're auditing the shop. Which line is the trust boundary?
For each remote on your map, run the same checklist. All three answers should be "yes":
The classic fail is answering "no" to #2. Here's the shop handler from the server authority lesson, revisited as an audit finding:
buyEvent.OnServerEvent:Connect(function(player, itemId, price)
if price >= 50 then -- "trust the price the client reported"
takeCoins(player, price)
giveItem(player, itemId)
end
end)
Which answer turns this audit finding into a clean pass?
The most common audit finding in a young game is a handler that uses remote arguments without checking them. It's also the easiest to fix, because the fix is one or two lines at the top of the handler — before anything expensive happens. An itemId from the client that the server looks up in a is a rule, not a fact, so the audit asks: is the key verified against a catalog the server trusts?
buyEvent.OnServerEvent:Connect(function(player, itemId)
giveItem(player, itemId) -- any id, whatever the client says
end)
What's the bug here?
The fix is the same shape every time: look the value up in the catalog. The hardened handler reads the price from that , and every failed check is a silent return — nothing leaks to the attacker:
local SHOP = {
Sword = { price = 50 },
Potion = { price = 5 },
}
buyEvent.OnServerEvent:Connect(function(player, itemId)
local item = SHOP[itemId]
if not item then return end -- no such thing is for sale
local coins = player.leaderstats.Coins
if coins.Value < item.price then return end -- can't afford it
coins.Value -= item.price
giveItem(player, itemId)
end)
buyEvent.OnServerEvent:Connect(function(player, itemId)
local item = SHOP[itemId]
local coins = player.leaderstats.Coins
if coins.Value < item.price then return end
coins.Value -= item.price
giveItem(player, itemId)
end)
Write the guard that drops requests for items that aren't in the catalog.
Handlers that receive typed text get the same treatment, with the input validation checklist on top. An audit of your chat path looks for three lines — in this order:
if typeof(message) ~= "string" then return end -- shape first
if #message > 200 then return end -- then size
message = message:gsub("[\0\r\n]", " ") -- content cleaned
if not string.match(message, "^%w+$") then return end -- whitelist shape
Your audit found the chat handler using message before any check. Add the shape guard that drops anything that isn't a string.
chatEvent.OnServerEvent:Connect(function(player, message)
-- only real text counts as a message
-- ... broadcast to the lobby
end)Length caps and control-character stripping are server rules. A MaxLength on a TextBox only stops honest ; the exploiter fires the remote directly, so the server cap is the one the audit cares about.
The last question is pace: can a single flood this boundary? A buy remote with no per- cooldown lets an exploiter drain their balance into the whole inventory in one second — and lets a cheater spam millions of requests to stress the server even if every one is rejected.
The audit doesn't re-litigate how to build a rate limit — that's the rate limiting lesson. It just checks that every accepting handler has one. The moment you find a FireServer whose handler has no cooldown, the finding is: pace this boundary. Client don't count (they only stop honest ); the limit has to live on the server, next to the code that rewards.
During your audit you find the coin remote has a debounce in the LocalScript but no server-side limit. How do you write the finding?
Before you ship, run the audit once, cover to cover — not just over "the suspicious ":
FireServer( and OnServerEvent; list every trust boundary.The classic trap is auditing for bugs you already know about. The audit's value is the boring checklist: the second remote nobody remembers, the chat path without the typeof guard, the buy handler with no cooldown. The exploiter reads the boring first.
Next up: the data bug hunt — put the whole save-and-remote stack under attack, and check it against the map you just built.