extends TestCase ## Issue N6: the discovery messages. Round trips, the rule that no answer is bigger ## than the query that asked for it, and malformed input refused without errors. func _server(port: int = 24650, name: String = "Harbour Light") -> Dictionary: return NetDiscovery.info(port, 3, 24, Match.PLAY, name) func test_query_round_trip_and_padding() -> void: var bytes: PackedByteArray = NetDiscovery.encode_query(7) assert_eq(bytes.size(), NetDiscovery.QUERY_BYTES) assert_eq(NetDiscovery.decode_query(bytes), {"version": NetProtocol.VERSION, "page": 7}) assert_eq(NetDiscovery.decode_query(bytes.slice(0, 64)), {}, "an unpadded query is refused") func test_info_round_trip() -> void: var server: Dictionary = _server() var decoded: Dictionary = NetDiscovery.decode_info(NetDiscovery.encode_info(server)) assert_eq(decoded, server) func test_register_and_challenge_round_trip() -> void: var server: Dictionary = _server(24652) var decoded: Dictionary = NetDiscovery.decode_register(NetDiscovery.encode_register(0xDEADBEEF, server)) assert_eq(decoded["token"], 0xDEADBEEF) decoded.erase("token") assert_eq(decoded, server) assert_eq(NetDiscovery.decode_challenge(NetDiscovery.encode_challenge(42)), {"token": 42}) func test_list_round_trip() -> void: var entries: Array[Dictionary] = [] for index: int in NetDiscovery.ENTRIES_PER_PAGE: var entry: Dictionary = _server(24650 + index * 2, "Server %d" % index) entry["address"] = "2001:db8::%d" % index if index % 2 == 0 else "192.0.2.%d" % (index + 1) entries.append(entry) var decoded: Dictionary = NetDiscovery.decode_list(NetDiscovery.encode_list(1, 3, entries)) assert_eq(decoded["page"], 1) assert_eq(decoded["pages"], 3) assert_eq(decoded["servers"], entries) func test_no_answer_is_bigger_than_a_query() -> void: # The longest possible names and addresses. var long_name: String = "W".repeat(200) var entries: Array[Dictionary] = [] for index: int in NetDiscovery.ENTRIES_PER_PAGE + 3: var entry: Dictionary = NetDiscovery.info(65535, 255, 255, 255, long_name) entry["address"] = "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255" entries.append(entry) var list: PackedByteArray = NetDiscovery.encode_list(255, 255, entries) assert_true(list.size() <= NetDiscovery.QUERY_BYTES, "a full page is %d bytes" % list.size()) # That longest address isn't one an IP check accepts; a full-length plain one is. for entry: Dictionary in entries: entry["address"] = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" var decoded: Dictionary = NetDiscovery.decode_list(NetDiscovery.encode_list(255, 255, entries)) assert_eq((decoded.get("servers", []) as Array).size(), NetDiscovery.ENTRIES_PER_PAGE) var info: PackedByteArray = NetDiscovery.encode_info(entries[0]) assert_true(info.size() <= NetDiscovery.QUERY_BYTES) assert_true(NetDiscovery.encode_challenge(1).size() < NetDiscovery.encode_register(0, entries[0]).size(), "a challenge is smaller than what prompted it") # Multi-byte names are cut on the byte limit too. var wide: Dictionary = NetDiscovery.info(1, 0, 1, 0, "浪".repeat(40)) assert_true(String(wide["name"]).to_utf8_buffer().size() <= NetDiscovery.SERVER_NAME_MAX_BYTES) func test_server_names_are_cleaned() -> void: assert_eq(NetDiscovery.clean_server_name(" Harbour\u202E Light\t "), "Harbour Light") assert_eq(NetDiscovery.clean_server_name(""), NetDiscovery.DEFAULT_SERVER_NAME) assert_eq(NetDiscovery.clean_server_name("\u200B\u0007"), NetDiscovery.DEFAULT_SERVER_NAME) assert_eq(NetDiscovery.clean_server_name("A".repeat(60)).length(), NetDiscovery.SERVER_NAME_MAX_CHARS) func test_list_entries_with_bad_addresses_or_fields_are_refused() -> void: var entry: Dictionary = _server() entry["address"] = "192.0.2.1" var good: PackedByteArray = NetDiscovery.encode_list(0, 1, [entry]) assert_false(NetDiscovery.decode_list(good).is_empty()) var bad_address: PackedByteArray = good.duplicate() bad_address[9] = 0x2F # "/" in the address assert_eq(NetDiscovery.decode_list(bad_address), {}) var trailing: PackedByteArray = good.duplicate() trailing.append(0) assert_eq(NetDiscovery.decode_list(trailing), {}) var crowded: Dictionary = NetDiscovery.info(24650, 30, 24, 0, "x") assert_eq(NetDiscovery.decode_info(NetDiscovery.encode_info(crowded)).get("players", -1), 24, "clamped when made") var raw: PackedByteArray = NetDiscovery.encode_info(_server()) raw[9] = 30 # more people than places assert_eq(NetDiscovery.decode_info(raw), {}) raw = NetDiscovery.encode_info(_server()) raw.encode_u16(7, 0) # no game port assert_eq(NetDiscovery.decode_info(raw), {}) ## Random and mutated messages: every decoder and the list server's handler take them ## all without an engine error or growing without bound. func test_fuzzed_messages_are_refused_quietly() -> void: var rng: RandomNumberGenerator = RandomNumberGenerator.new() rng.seed = 612 var seeds: Array[PackedByteArray] = [ NetDiscovery.encode_query(), NetDiscovery.encode_info(_server()), NetDiscovery.encode_register(9, _server()), NetDiscovery.encode_challenge(9), ] var entry: Dictionary = _server() entry["address"] = "198.51.100.4" seeds.append(NetDiscovery.encode_list(0, 1, [entry, entry])) var list: ListServer = ListServer.new() list.limiter = SourceLimiter.new(1 << 30) var accepted: int = 0 for round_index: int in 40000: var bytes: PackedByteArray if round_index % 4 == 0: bytes = PackedByteArray() bytes.resize(rng.randi_range(0, 600)) for index: int in bytes.size(): bytes[index] = rng.randi_range(0, 255) else: bytes = seeds[rng.randi_range(0, seeds.size() - 1)].duplicate() for _flip: int in rng.randi_range(1, 4): if bytes.is_empty(): break match rng.randi_range(0, 2): 0: bytes[rng.randi_range(0, bytes.size() - 1)] = rng.randi_range(0, 255) 1: bytes.resize(rng.randi_range(0, bytes.size())) 2: bytes.append(rng.randi_range(0, 255)) for decoded: Dictionary in [ NetDiscovery.decode_query(bytes), NetDiscovery.decode_info(bytes), NetDiscovery.decode_register(bytes), NetDiscovery.decode_challenge(bytes), NetDiscovery.decode_list(bytes), ]: if not decoded.is_empty(): accepted += 1 list.handle(bytes, "203.0.113.%d" % (round_index % 200), 40000 + round_index % 7, 0) assert_true(accepted > 0, "some mutations are still valid messages") assert_true(list.entry_count() <= ListServer.MAX_ENTRIES) # Nothing registered without the token: a fuzzer can't guess it. assert_eq(list.entry_count(), 0)