## 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)) 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), 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, ] bytes[0] = types[rng.randi_range(0, types.size() - 1)]