@axpecter/lync 2.1.2 → 2.2.1

package/src/transport/Reader.luau

@@ -10,28 +10,60 @@ local Registry = require(script.Parent.Parent.internal.Registry)
 local Types = require(script.Parent.Parent.Types)
 local Varint = require(script.Parent.Parent.codec.primitive.Varint)
 
--- Constants -----------------------------------------------------------
+-- Constants --------------------------------------------------------------
 
 local KIND_PACKET = Registry.KIND_PACKET
 local KIND_REQUEST = Registry.KIND_REQUEST
 local KIND_RESPONSE = Registry.KIND_RESPONSE
 
--- Private -------------------------------------------------------------
+local TS_FRAME = Channel.TS_FRAME
+local TS_OFFSET = Channel.TS_OFFSET
+local TS_FULL = Channel.TS_FULL
+
+local MAX_ITEMS_PER_FRAME = 0xFFFF
+
+-- Private ----------------------------------------------------------------
 
 local band = bit32.band
 local readu8 = buffer.readu8
 
--- Public --------------------------------------------------------------
+local function recordDrop(
+    reg: Types.Registration,
+    statsEnabled: boolean,
+    player: Player?,
+    reason: string,
+    value: any
+): ()
+    if statsEnabled then
+        reg.drops += 1
+    end
+    if player then
+        Middleware.fireDrop(player, reason, reg.name, value)
+    end
+end
+
+-- Public -----------------------------------------------------------------
 
 local Reader = {}
 
+--[[
+    Sanity-check an inbound RemoteEvent payload. The size cap MUST NOT be
+    tied to the local `Channel.maxSize()` — sender and receiver run in
+    separate Lua VMs with independent module state, so the receiver may
+    not have called Lync.configure with the same channelMaxSize. Coupling
+    them caused server frames larger than the receiver's local default to
+    be silently dropped, which permanently desynced the XOR baseline.
+
+    Roblox enforces a per-RemoteEvent payload ceiling around 1MB; if the
+    payload reached us at all, it's already within Roblox's limit. Trust
+    that and accept anything non-empty.
+]]
 function Reader.decodeIncoming(data: any): buffer?
     if typeof(data) ~= "buffer" then
         return nil
     end
     local b = data :: buffer
-    local len = buffer.len(b)
-    if len == 0 or len > 65536 then
+    if buffer.len(b) == 0 then
         return nil
     end
     return b
@@ -44,7 +76,6 @@ function Reader.process(
     player: Player?,
     isServer: boolean
 ): ()
-    -- Set baseline read key for delta codecs
     if Baseline.hasDelta() then
         Baseline.setReadKey(player or false)
     end
@@ -54,6 +85,7 @@ function Reader.process(
     local pos = 0
 
     while pos < incomingLen do
+        local frameStart = pos
         local raw = readu8(incoming, pos)
         pos += 1
 
@@ -62,87 +94,85 @@ function Reader.process(
 
         local reg = Registry.get(id)
         if not reg then
-            warn(`[Lync] Reader: unknown packet ID {id} at byte {pos - 1}`)
-            break
+            warn(`[Lync] Reader.process: unknown packet ID {id} at byte {pos - 1}`)
+            return
         end
 
         if reg.kind == KIND_PACKET then
             local count: number
-
             if msb then
                 count = 1
             else
+                if pos + 2 > incomingLen then
+                    warn("[Lync] Reader.process: truncated multi-frame header")
+                    return
+                end
                 count = buffer.readu16(incoming, pos)
                 pos += 2
             end
 
-            -- Read timestamp if this packet has one configured
             local tsMode = reg.timestampMode
-            local tsValue: any = nil
-
-            if tsMode == Channel.TS_FRAME then
+            local tsValue: number? = nil
+            if tsMode == TS_FRAME then
                 tsValue = readu8(incoming, pos)
                 pos += 1
-            elseif tsMode == Channel.TS_OFFSET then
+            elseif tsMode == TS_OFFSET then
                 tsValue = buffer.readu16(incoming, pos)
                 pos += 2
-            elseif tsMode == Channel.TS_FULL then
+            elseif tsMode == TS_FULL then
                 tsValue = buffer.readf64(incoming, pos)
                 pos += 8
             end
 
-            -- Prevent a malicious count from reading past the buffer
-            if reg.codec._size then
-                local maxItems = (incomingLen - pos) // (reg.codec._size :: number)
-                if count > maxItems then
-                    count = maxItems
+            if count > MAX_ITEMS_PER_FRAME then
+                count = MAX_ITEMS_PER_FRAME
+            end
+            local sizeMeta = reg.codec._size
+            if sizeMeta then
+                local maxBySize = (incomingLen - pos) // sizeMeta
+                if count > maxBySize then
+                    count = maxBySize
                 end
             end
 
+            local maxPayload = reg.maxPayloadBytes
+            local payloadStart = pos
+
             for _ = 1, count do
                 local value, consumed = reg.codec.read(incoming, pos, refs)
+                if consumed == 0 then
+                    warn(
+                        `[Lync] Reader.process: codec for "{reg.name}" reported 0 bytes; aborting frame`
+                    )
+                    return
+                end
                 pos += consumed
 
+                if maxPayload and (pos - payloadStart) > maxPayload then
+                    recordDrop(reg, statsEnabled, player, "maxPayloadBytes", value)
+                    return
+                end
+
                 if isServer and reg.needsGate then
                     if player and not Gate.checkGlobalRateLimit(player) then
-                        if statsEnabled then
-                            reg.drops += 1
-                        end
-                        Middleware.fireDrop(player :: Player, "rate", reg.name, value)
+                        recordDrop(reg, statsEnabled, player, "rate", value)
                         continue
                     end
-
                     if player and not Gate.checkRateLimit(reg, player) then
-                        if statsEnabled then
-                            reg.drops += 1
-                        end
-                        Middleware.fireDrop(player :: Player, "rate", reg.name, value)
+                        recordDrop(reg, statsEnabled, player, "rate", value)
                         continue
                     end
 
-                    local ok, reason = Gate.validate(value, reg.codec)
+                    local ok = Gate.validate(value, reg.codec)
                     if not ok then
-                        if statsEnabled then
-                            reg.drops += 1
-                        end
-                        if player then
-                            Middleware.fireDrop(player, "validation", reg.name, value)
-                        end
+                        recordDrop(reg, statsEnabled, player, "validation", value)
                         continue
                     end
 
-                    if reg.validate then
-                        local valid, validReason = reg.validate(value, player :: Player)
+                    if reg.validate and player then
+                        local valid, validReason = reg.validate(value, player)
                         if not valid then
-                            if statsEnabled then
-                                reg.drops += 1
-                            end
-                            Middleware.fireDrop(
-                                player :: Player,
-                                validReason or "validate",
-                                reg.name,
-                                value
-                            )
+                            recordDrop(reg, statsEnabled, player, validReason or "validate", value)
                             continue
                         end
                     end
@@ -164,55 +194,53 @@ function Reader.process(
             end
 
             if statsEnabled then
-                -- Approximate: counts all bytes consumed in this frame, not just payload
-                reg.bytesReceived += pos
+                reg.bytesReceived += (pos - frameStart)
             end
         elseif reg.kind == KIND_REQUEST or reg.kind == KIND_RESPONSE then
-            -- MSB distinguishes nil responses (no payload) from data responses
             local corrId, corrBytes = Varint.read(incoming, pos)
             pos += corrBytes
 
             if msb then
                 if statsEnabled then
                     reg.recvFires += 1
+                    reg.bytesReceived += (pos - frameStart)
                 end
                 reg.signal:fire(nil, player, corrId)
             else
                 local value, consumed = reg.codec.read(incoming, pos, refs)
+                if consumed == 0 then
+                    warn(
+                        `[Lync] Reader.process: query codec for "{reg.name}" reported 0 bytes; aborting frame`
+                    )
+                    return
+                end
                 pos += consumed
 
                 if isServer and reg.needsGate and reg.kind == KIND_REQUEST then
                     if player and not Gate.checkRateLimit(reg, player) then
+                        recordDrop(reg, statsEnabled, player, "rate", value)
                         if statsEnabled then
-                            reg.drops += 1
+                            reg.bytesReceived += (pos - frameStart)
                         end
-                        Middleware.fireDrop(player :: Player, "rate", reg.name, value)
                         continue
                     end
 
-                    local ok, reason = Gate.validate(value, reg.codec)
+                    local ok = Gate.validate(value, reg.codec)
                     if not ok then
+                        recordDrop(reg, statsEnabled, player, "validation", value)
                         if statsEnabled then
-                            reg.drops += 1
-                        end
-                        if player then
-                            Middleware.fireDrop(player, "validation", reg.name, value)
+                            reg.bytesReceived += (pos - frameStart)
                         end
                         continue
                     end
 
-                    if reg.validate then
-                        local valid, validReason = reg.validate(value, player :: Player)
+                    if reg.validate and player then
+                        local valid, validReason = reg.validate(value, player)
                         if not valid then
+                            recordDrop(reg, statsEnabled, player, validReason or "validate", value)
                             if statsEnabled then
-                                reg.drops += 1
+                                reg.bytesReceived += (pos - frameStart)
                             end
-                            Middleware.fireDrop(
-                                player :: Player,
-                                validReason or "validate",
-                                reg.name,
-                                value
-                            )
                             continue
                         end
                     end
@@ -224,6 +252,7 @@ function Reader.process(
 
                 if statsEnabled then
                     reg.recvFires += 1
+                    reg.bytesReceived += (pos - frameStart)
                 end
                 reg.signal:fire(value, player, corrId)
             end

package/src/transport/Server.luau

@@ -1,8 +1,10 @@
 --!strict
 --!optimize 2
 -- Server-side transport: per-player channels, broadcast, flush.
+-- Decodes inbound XOR delta against a per-player baseline.
 
 local Players = game:GetService("Players")
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
 
 local Baseline = require(script.Parent.Parent.internal.Baseline)
 local Bridge = require(script.Parent.Parent.transport.Bridge)
@@ -12,186 +14,189 @@ local Pool = require(script.Parent.Parent.internal.Pool)
 local Reader = require(script.Parent.Parent.transport.Reader)
 local Types = require(script.Parent.Parent.Types)
 
--- State ---------------------------------------------------------------
+-- Constants --------------------------------------------------------------
+
+local CONTAINER_NAME = "LyncRemotes"
+
+-- State ------------------------------------------------------------------
 
 local _reliableChannels: { [Player]: Types.ChannelState } = {}
 local _unreliableChannels: { [Player]: Types.ChannelState } = {}
 local _playerStats: { [Player]: Types.PlayerStats } = {}
-local _statsEnabled = false
+local _prevIncoming: { [Player]: buffer } = {}
+local _prevIncomingLen: { [Player]: number } = {}
 
--- Private -------------------------------------------------------------
+local _statsEnabled = false
 
-local function getReliable(player: Player): Types.ChannelState
-    local ch = _reliableChannels[player]
-    if not ch then
-        ch = Pool.acquire()
-        _reliableChannels[player] = ch
-    end
-    return ch
-end
+-- Private ----------------------------------------------------------------
 
-local function getUnreliable(player: Player): Types.ChannelState
-    local ch = _unreliableChannels[player]
+local function getOrCreateChannel(
+    map: { [Player]: Types.ChannelState },
+    player: Player
+): Types.ChannelState
+    local ch = map[player]
     if not ch then
         ch = Pool.acquire()
-        _unreliableChannels[player] = ch
+        map[player] = ch
     end
     return ch
 end
 
-local function flushPlayer(player: Player): ()
-    -- Reliable channel
+local function flushReliable(player: Player): ()
     local rCh = _reliableChannels[player]
-    if rCh and rCh.cursor > 0 then
-        local snapshot, refs, byteLen, refCount = Channel.sealAndDump(rCh)
+    if not rCh or rCh.cursor == 0 then
+        return
+    end
 
-        -- XOR against previous frame
-        local xored = Channel.xorApply(snapshot, byteLen, rCh.prevDump, rCh.prevDumpLen)
-        rCh.prevDump = snapshot
-        rCh.prevDumpLen = byteLen
+    local snapshot, refs, byteLen = Channel.sealAndDump(rCh)
+    local xored = Channel.xorApply(snapshot, byteLen, rCh.prevDump, rCh.prevDumpLen)
+    rCh.prevDump = snapshot
+    rCh.prevDumpLen = byteLen
 
-        Bridge.fireClient(player, xored, refs)
-        Channel.reset(rCh)
+    Bridge.fireClient(player, xored, refs)
+    Channel.reset(rCh)
 
-        if _statsEnabled then
-            local ps = _playerStats[player]
-            if ps then
-                ps.bytesSent += byteLen
-            end
+    if _statsEnabled then
+        local ps = _playerStats[player]
+        if ps then
+            ps.bytesSent += byteLen
         end
     end
+end
 
-    -- Unreliable channel (no XOR, no delta)
+local function flushUnreliable(player: Player): ()
     local uCh = _unreliableChannels[player]
-    if uCh and uCh.cursor > 0 then
-        local snapshot, refs, byteLen, _ = Channel.sealAndDump(uCh)
+    if not uCh or uCh.cursor == 0 then
+        return
+    end
 
-        Bridge.fireClientUnreliable(player, snapshot, refs)
-        Channel.reset(uCh)
+    local snapshot, refs, byteLen = Channel.sealAndDump(uCh)
+    Bridge.fireClientUnreliable(player, snapshot, refs)
+    Channel.reset(uCh)
 
-        if _statsEnabled then
-            local ps = _playerStats[player]
-            if ps then
-                ps.bytesSent += byteLen
-            end
+    if _statsEnabled then
+        local ps = _playerStats[player]
+        if ps then
+            ps.bytesSent += byteLen
         end
     end
 end
 
--- Public --------------------------------------------------------------
-
-local Server = {}
-
-function Server.getChannel(player: Player, isUnreliable: boolean): Types.ChannelState
-    return if isUnreliable then getUnreliable(player) else getReliable(player)
+local function flushPlayer(player: Player): ()
+    flushReliable(player)
+    flushUnreliable(player)
 end
 
-function Server.flush(): ()
-    if Channel.hasTimestamps() then
-        Channel.updateTimestamp()
+local function handleIncomingReliable(player: Player, data: any, refs: any?): ()
+    local incoming = Reader.decodeIncoming(data)
+    if not incoming then
+        return
     end
 
-    for player in _reliableChannels do
-        flushPlayer(player)
+    local incomingLen = buffer.len(incoming)
+    if not Gate.checkBandwidth(player, incomingLen) then
+        return
+    end
+
+    local prev = _prevIncoming[player]
+    local decoded = if prev
+        then Channel.xorApply(incoming, incomingLen, prev, _prevIncomingLen[player])
+        else incoming
+    _prevIncoming[player] = decoded
+    _prevIncomingLen[player] = incomingLen
+
+    local ok, err = pcall(Reader.process, decoded, incomingLen, refs, player, true)
+    if not ok then
+        warn(`[Lync] Server.receive: {player.Name}: {err}`)
     end
 
-    for player in _unreliableChannels do
-        if not _reliableChannels[player] then
-            flushPlayer(player)
+    if _statsEnabled then
+        local ps = _playerStats[player]
+        if ps then
+            ps.bytesReceived += incomingLen
         end
     end
 end
 
-function Server.flushPlayer(player: Player): ()
-    flushPlayer(player)
-end
+local function handleIncomingUnreliable(player: Player, data: any, refs: any?): ()
+    local incoming = Reader.decodeIncoming(data)
+    if not incoming then
+        return
+    end
 
-function Server.start(): ()
-    local container = Instance.new("Folder")
-    container.Name = "LyncRemotes"
-    container.Parent = game:GetService("ReplicatedStorage")
+    local incomingLen = buffer.len(incoming)
+    local ok, err = pcall(Reader.process, incoming, incomingLen, refs, player, true)
+    if not ok then
+        warn(`[Lync] Server.receiveUnreliable: {player.Name}: {err}`)
+    end
 
-    Bridge.setup(container)
+    if _statsEnabled then
+        local ps = _playerStats[player]
+        if ps then
+            ps.bytesReceived += incomingLen
+        end
+    end
+end
 
-    local reliable = Bridge.reliable()
-    local unreliable = Bridge.unreliable()
+local function clearPlayerState(player: Player): ()
+    local rCh = _reliableChannels[player]
+    if rCh then
+        _reliableChannels[player] = nil
+        Pool.release(rCh)
+    end
+    local uCh = _unreliableChannels[player]
+    if uCh then
+        _unreliableChannels[player] = nil
+        Pool.release(uCh)
+    end
 
-    -- Incoming reliable
-    reliable.OnServerEvent:Connect(function(player: Player, data: any, refs: any?)
-        local incoming = Reader.decodeIncoming(data)
-        if not incoming then
-            return
-        end
+    _playerStats[player] = nil
+    _prevIncoming[player] = nil
+    _prevIncomingLen[player] = nil
 
-        local incomingLen = buffer.len(incoming)
+    Gate.clearPlayer(player)
+    Baseline.clearPlayer(player)
+end
 
-        -- Bandwidth check
-        if not Gate.checkBandwidth(player, incomingLen) then
-            return
-        end
+-- Public -----------------------------------------------------------------
 
-        -- XOR decode against player's previous outbound (client→server has no XOR)
-        local ok, err = pcall(Reader.process, incoming, incomingLen, refs :: any, player, true)
-        if not ok then
-            warn(`[Lync] Server: read error from {player.Name}: {err}`)
-        end
+local Server = {}
 
-        if _statsEnabled then
-            local ps = _playerStats[player]
-            if ps then
-                ps.bytesReceived += incomingLen
-            end
-        end
-    end)
+function Server.getChannel(player: Player, isUnreliable: boolean): Types.ChannelState
+    return getOrCreateChannel(
+        if isUnreliable then _unreliableChannels else _reliableChannels,
+        player
+    )
+end
 
-    -- Incoming unreliable
-    unreliable.OnServerEvent:Connect(function(player: Player, data: any, refs: any?)
-        local incoming = Reader.decodeIncoming(data)
-        if not incoming then
-            return
-        end
+function Server.flush(): ()
+    if Channel.hasTimestamps() then
+        Channel.updateTimestamp()
+    end
+    for _, player in Players:GetPlayers() do
+        flushPlayer(player)
+    end
+end
 
-        local incomingLen = buffer.len(incoming)
+Server.flushPlayer = flushPlayer
 
-        local ok, err = pcall(Reader.process, incoming, incomingLen, refs :: any, player, true)
-        if not ok then
-            warn(`[Lync] Server: read error (unreliable) from {player.Name}: {err}`)
-        end
+function Server.start(): ()
+    local container = Instance.new("Folder")
+    container.Name = CONTAINER_NAME
+    container.Parent = ReplicatedStorage
 
-        if _statsEnabled then
-            local ps = _playerStats[player]
-            if ps then
-                ps.bytesReceived += incomingLen
-            end
-        end
-    end)
+    Bridge.setup(container)
+
+    Bridge.reliable().OnServerEvent:Connect(handleIncomingReliable)
+    Bridge.unreliable().OnServerEvent:Connect(handleIncomingUnreliable)
 
-    -- Player lifecycle
     Players.PlayerAdded:Connect(function(player: Player)
         if _statsEnabled then
             _playerStats[player] = { bytesSent = 0, bytesReceived = 0 }
         end
     end)
+    Players.PlayerRemoving:Connect(clearPlayerState)
 
-    Players.PlayerRemoving:Connect(function(player: Player)
-        local rCh = _reliableChannels[player]
-        if rCh then
-            _reliableChannels[player] = nil
-            Pool.release(rCh)
-        end
-
-        local uCh = _unreliableChannels[player]
-        if uCh then
-            _unreliableChannels[player] = nil
-            Pool.release(uCh)
-        end
-
-        _playerStats[player] = nil
-        Gate.clearPlayer(player)
-        Baseline.clearPlayer(player)
-    end)
-
-    -- Initialize stats for existing players
     if _statsEnabled then
         for _, player in Players:GetPlayers() do
             _playerStats[player] = { bytesSent = 0, bytesReceived = 0 }
@@ -208,7 +213,7 @@ function Server.getPlayerStats(player: Player): Types.PlayerStats?
 end
 
 function Server.resetStats(): ()
-    for player, ps in _playerStats do
+    for _, ps in _playerStats do
         ps.bytesSent = 0
         ps.bytesReceived = 0
     end