- Build ghost: ClientSession shows a BuildGhost in build mode while the client plays, asking Building.check() of its own world and predicted player with the mouse's newest look, so it agrees with the server. - Flooded basins: ClientMirror.follow_flood() spreads the client's flood as the server's tide tick does, from the tide and the pieces it has. WaterView passes a mask of flooded cells (Flood.pours says when it changed) to the sea shader, which leaves dry cells undrawn. - Shots, impacts and swings: a new FX message (NetFx) goes unreliably on the state channel next to each snapshot, with what happened within NET_FX_RADIUS_METRES of what the client watches or involving that player. ClientGame keeps them in `fx` for views and sound. They change no state, so a lost one is a missed flash; sending them reliably would add to the traffic a bad link can least afford (N8). The fuzzer covers the new parser. - Captures: client_build and client_build_refused show the ghost in its allowed and refused tints; client_basin rings shore ground with breakwaters and plays until the tide stands over it, and the server, the client's flood and the drawn sea all keep the basin dry. - Tests: NetFx round trips, limits and malformed input; a landed player's shots and impacts reach a client, each matching a server event; the client keeps a ringed basin dry through the first rise, floods it with no ring, catches up after a long frame; the water mask follows pours. The held item is still not drawn; that needs the models (A4, #44). Closes #78 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
163 lines
6.4 KiB
GDScript
163 lines
6.4 KiB
GDScript
## Feeds malformed messages to every parser that reads bytes from the network: the
|
|
## handshake, inputs, snapshots, match notices, world and inventory messages, and
|
|
## discovery, plus the stateful snapshot receiver and the list server's handler.
|
|
## Messages are mutations of real ones taken from a running match (bit flips,
|
|
## truncation, extension, splices, runs of 0x00 and 0xFF, a different type byte) and
|
|
## plain random bytes.
|
|
##
|
|
## Used by test_parser_fuzz.gd with a small count and by `make fuzz` with 1,000,000.
|
|
## Nothing here may raise an engine error; whoever runs it checks that.
|
|
class_name ParserFuzz
|
|
extends RefCounted
|
|
|
|
const MAX_LENGTH: int = 1600
|
|
|
|
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
|
|
## Real messages to mutate.
|
|
var seeds: Array[PackedByteArray] = []
|
|
var messages: int = 0
|
|
## Messages some parser accepted as well formed.
|
|
var accepted: int = 0
|
|
## Static memory in use after the warm-up and at the end, in bytes.
|
|
var memory_start: int = 0
|
|
var memory_end: int = 0
|
|
var memory_peak: int = 0
|
|
|
|
var _receiver: SnapshotReceiver = SnapshotReceiver.new()
|
|
var _list: ListServer = ListServer.new()
|
|
|
|
|
|
func _init(fuzz_seed: int) -> void:
|
|
rng.seed = fuzz_seed
|
|
# The list server has no socket here, so it answers nothing; and no rate limit,
|
|
# so every message reaches its parser.
|
|
_list.limiter = SourceLimiter.new(1 << 30)
|
|
|
|
|
|
## Takes real messages from a short bot match: snapshots, world, inventory and match
|
|
## notices, plus one of every handshake and discovery message.
|
|
func collect_seeds() -> void:
|
|
var loop: ServerLoop = ServerLoop.new(9, 1, 5, null)
|
|
var game: NetGame = NetGame.new(loop, NetServer.new())
|
|
game.adopt(1)
|
|
seeds.append(game.world_notice())
|
|
seeds.append(game.match_notice())
|
|
for tick: int in 150:
|
|
loop.run_tick()
|
|
game.after_tick()
|
|
if not game.world_changes.is_empty():
|
|
seeds.append(game.world_changes)
|
|
for bytes: PackedByteArray in game.own_changes.values():
|
|
seeds.append(bytes)
|
|
if tick % 10 == 0:
|
|
seeds.append(game.snapshot_for(1))
|
|
seeds.append(NetFx.encode([
|
|
{"kind": NetFx.SHOT, "tick": 90, "player": 3, "item": 2, "position": Vector3(100.0, 12.0, 200.0), "yaw": 1.0, "pitch": -0.2},
|
|
{"kind": NetFx.IMPACT, "tick": 91, "player": 3, "item": 2, "position": Vector3(110.0, 11.0, 210.0), "hit": Weapons.HIT_PLAYER, "target": 7},
|
|
{"kind": NetFx.HARVEST, "tick": 92, "player": 4, "item": -1, "position": Vector3(50.0, 9.0, 60.0), "prop": 12, "piece": 0},
|
|
] as Array[Dictionary]))
|
|
var command: PlayerCommand = PlayerCommand.from_input(12, Vector2(0.3, 1.0), 1.0, 0.2, PlayerCommand.BUTTON_FIRE, 2, 1)
|
|
seeds.append(NetSnapshot.encode_input(40, [command, command] as Array[PlayerCommand]))
|
|
seeds.append(NetProtocol.encode_hello("Fuzzer"))
|
|
seeds.append(NetProtocol.encode_welcome(3, 77, 24, "Fuzzer"))
|
|
seeds.append(NetProtocol.encode_reject(NetProtocol.REASON_FULL))
|
|
var info: Dictionary = NetDiscovery.info(24650, 3, 24, 1, "Fuzz Harbour")
|
|
seeds.append(NetDiscovery.encode_query(1))
|
|
seeds.append(NetDiscovery.encode_info(info))
|
|
seeds.append(NetDiscovery.encode_register(5, info))
|
|
seeds.append(NetDiscovery.encode_challenge(5))
|
|
info["address"] = "192.0.2.4"
|
|
seeds.append(NetDiscovery.encode_list(0, 1, [info, info] as Array[Dictionary]))
|
|
|
|
|
|
## Runs `count` messages through every parser.
|
|
func run(count: int) -> void:
|
|
if seeds.is_empty():
|
|
collect_seeds()
|
|
var warm: int = mini(count, 2000)
|
|
for index: int in count:
|
|
if index == warm:
|
|
memory_start = OS.get_static_memory_usage()
|
|
feed(next_message())
|
|
if index % 10000 == 0:
|
|
memory_peak = maxi(memory_peak, OS.get_static_memory_usage())
|
|
memory_end = OS.get_static_memory_usage()
|
|
memory_peak = maxi(memory_peak, memory_end)
|
|
|
|
|
|
func next_message() -> PackedByteArray:
|
|
if rng.randf() < 0.15:
|
|
var noise: PackedByteArray = PackedByteArray()
|
|
noise.resize(rng.randi_range(0, MAX_LENGTH))
|
|
for index: int in noise.size():
|
|
noise[index] = rng.randi() & 0xFF
|
|
return noise
|
|
var bytes: PackedByteArray = seeds[rng.randi_range(0, seeds.size() - 1)].duplicate()
|
|
for _change: int in rng.randi_range(1, 4):
|
|
_mutate(bytes)
|
|
if bytes.size() > MAX_LENGTH:
|
|
bytes.resize(MAX_LENGTH)
|
|
return bytes
|
|
|
|
|
|
func feed(bytes: PackedByteArray) -> void:
|
|
messages += 1
|
|
var results: Array = [
|
|
NetProtocol.decode_hello(bytes), NetProtocol.decode_welcome(bytes), NetProtocol.decode_reject(bytes),
|
|
NetSnapshot.decode_input(bytes), NetSnapshot.decode_snapshot(bytes), NetSnapshot.decode_match(bytes),
|
|
NetWorld.decode_world(bytes), NetWorld.decode_own(bytes), NetFx.decode(bytes),
|
|
NetDiscovery.decode_query(bytes), NetDiscovery.decode_info(bytes), NetDiscovery.decode_register(bytes),
|
|
NetDiscovery.decode_challenge(bytes), NetDiscovery.decode_list(bytes),
|
|
]
|
|
for result: Dictionary in results:
|
|
if not result.is_empty():
|
|
accepted += 1
|
|
break
|
|
_receiver.apply(bytes)
|
|
_list.handle(bytes, "198.51.100.%d" % (messages % 250 + 1), 40000 + messages % 13, messages)
|
|
# Keep the list server's state from being the thing that grows.
|
|
if messages % 5000 == 0:
|
|
_list.expire(messages + ListServer.ENTRY_TTL_MSEC + 1)
|
|
|
|
|
|
func listed() -> int:
|
|
return _list.entry_count()
|
|
|
|
|
|
func _mutate(bytes: PackedByteArray) -> void:
|
|
match rng.randi_range(0, 6):
|
|
0:
|
|
if not bytes.is_empty():
|
|
var at: int = rng.randi_range(0, bytes.size() - 1)
|
|
bytes[at] = bytes[at] ^ (1 << rng.randi_range(0, 7))
|
|
1:
|
|
if not bytes.is_empty():
|
|
bytes[rng.randi_range(0, bytes.size() - 1)] = rng.randi() & 0xFF
|
|
2:
|
|
bytes.resize(rng.randi_range(0, bytes.size()))
|
|
3:
|
|
for _extra: int in rng.randi_range(1, 64):
|
|
bytes.append(rng.randi() & 0xFF)
|
|
4:
|
|
# A run of 0x00 or 0xFF: large counts, long varints, zero lengths.
|
|
if not bytes.is_empty():
|
|
var at: int = rng.randi_range(0, bytes.size() - 1)
|
|
var fill: int = 0xFF if rng.randf() < 0.5 else 0x00
|
|
for index: int in range(at, mini(at + rng.randi_range(1, 12), bytes.size())):
|
|
bytes[index] = fill
|
|
5:
|
|
var other: PackedByteArray = seeds[rng.randi_range(0, seeds.size() - 1)]
|
|
if not other.is_empty() and not bytes.is_empty():
|
|
var cut: int = rng.randi_range(0, bytes.size() - 1)
|
|
var from: int = rng.randi_range(0, other.size() - 1)
|
|
bytes.resize(cut)
|
|
bytes.append_array(other.slice(from))
|
|
6:
|
|
if not bytes.is_empty():
|
|
var types: Array[int] = [
|
|
NetProtocol.MSG_HELLO, NetProtocol.MSG_WELCOME, NetProtocol.MSG_REJECT, NetSnapshot.MSG_MATCH,
|
|
NetWorld.MSG_WORLD, NetWorld.MSG_OWN, NetSnapshot.MSG_SNAPSHOT, NetSnapshot.MSG_INPUT,
|
|
NetFx.MSG_FX,
|
|
]
|
|
bytes[0] = types[rng.randi_range(0, types.size() - 1)]
|