Files
tidewall/test/net/test_net_handshake.gd
claudeandClaude Opus 5.5 9b5064d7a8 H5: Security review, and fixes for connection-slot exhaustion
docs/SECURITY_REVIEW.md lists the scope, nine findings and what was done.

- High, fixed: a peer that connects and stops answering kept its ENet slot
  for up to 15 s after being turned away, so one address could fill every
  slot. Flood refusals now disconnect at once (reason in the disconnect
  data, which NetClient now honours for REASON_BUSY), peers told to leave
  get 1 s to acknowledge, and when slots run short the longest-waiting
  silent guest makes room.
- Medium, mitigated: ENet holds half-open slots for spoofed CONNECTs that
  the script never sees. The host now has 512 slots (NetServer.peer_slots).
- Medium, fixed: SourceLimiter, handshakes per source and the list
  server's per-address cap count an IPv6 /64 as one source.
- Low, fixed: CommandLog refuses a header with non-numeric fields instead
  of raising errors.
- tools/godot.sh unsets DISPLAY and WAYLAND_DISPLAY so the engine's error
  alerts can never reach the host desktop.
- A test fixture's 10.0.0.9 is now the documentation address 192.0.2.9.

Tests: 4 new handshake tests with real non-acknowledging ENet peers,
test_source_limiter (3), a CommandLog type test. make check, make fuzz,
make client-check, make discovery-check and make soak-selfcheck pass.

Closes #58

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 02:36:36 -05:00

486 lines
19 KiB
GDScript

extends TestCase
## Issue N1: a real NetServer and NetClients over loopback UDP. Handshake, refusals,
## clean leaves, timeouts, and hostile or broken peers.
const HOST: String = "127.0.0.1"
var server: NetServer
var clients: Array[NetClient] = []
## Every server event since the test began.
var seen: Array[Dictionary] = []
var raw_hosts: Array[ENetConnection] = []
## Game packets the server handed to its owner since the test began.
var handed: int = 0
func before_each() -> void:
server = NetServer.new()
server.match_seed = 4242
clients.clear()
seen.clear()
handed = 0
raw_hosts.clear()
assert_eq(server.listen(0, HOST), OK)
assert_true(server.port() > 0)
func after_each() -> void:
for client: NetClient in clients:
client.leave()
for host: ENetConnection in raw_hosts:
host.destroy()
server.close()
func _client(wanted: String) -> NetClient:
var client: NetClient = NetClient.new()
clients.append(client)
assert_eq(client.connect_to(HOST, server.port(), wanted), OK)
return client
## Polls everything until `done` is true or `limit_msec` passes. Returns `done`'s answer.
func _pump(done: Callable, limit_msec: int = 4000) -> bool:
var started: int = Time.get_ticks_msec()
while Time.get_ticks_msec() - started < limit_msec:
server.poll()
seen.append_array(server.events)
handed += server.packets.size()
for client: NetClient in clients:
client.poll()
for host: ENetConnection in raw_hosts:
_service_raw(host)
if done.call():
return true
OS.delay_msec(2)
return bool(done.call())
func _events(type: String) -> Array[Dictionary]:
var found: Array[Dictionary] = []
for event: Dictionary in seen:
if event["type"] == type:
found.append(event)
return found
# A bare ENet peer, for sending what a real client never would.
var _raw_state: Dictionary = {}
func _raw() -> ENetPacketPeer:
var host: ENetConnection = ENetConnection.new()
assert_eq(host.create_host(1, NetProtocol.CHANNEL_COUNT), OK)
var peer: ENetPacketPeer = host.connect_to_host(HOST, server.port(), NetProtocol.CHANNEL_COUNT)
raw_hosts.append(host)
_raw_state[host] = {"connected": false, "disconnect_data": -1, "packets": []}
assert_true(_pump(func() -> bool: return _raw_state[host]["connected"]), "the raw peer connected")
return peer
func _service_raw(host: ENetConnection) -> void:
while true:
var event: Array = host.service(0)
if event[0] == ENetConnection.EVENT_NONE or event[0] == ENetConnection.EVENT_ERROR:
return
var state: Dictionary = _raw_state[host]
if event[0] == ENetConnection.EVENT_CONNECT:
state["connected"] = true
elif event[0] == ENetConnection.EVENT_DISCONNECT:
state["disconnect_data"] = int(event[2])
elif event[0] == ENetConnection.EVENT_RECEIVE:
state["packets"].append((event[1] as ENetPacketPeer).get_packet())
func test_a_client_joins() -> void:
var client: NetClient = _client(" Mara\tof the Reef ")
assert_eq(client.state, NetClient.CONNECTING)
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED), client.status_text())
assert_eq(client.handle, 1)
assert_eq(client.player_name, "Mara of the Reef")
assert_eq(client.match_seed, 4242)
assert_eq(client.max_players, Tuning.SOLO_PLAYERS)
assert_eq(client.tick_rate, Tuning.TICK_RATE_HZ)
assert_eq(client.server_version, NetProtocol.VERSION)
assert_eq(_events("joined"), [{"type": "joined", "handle": 1, "name": "Mara of the Reef"}] as Array[Dictionary])
assert_eq(server.player_count(), 1)
assert_eq(server.guest_count(), 0)
assert_eq(server.name_of(1), "Mara of the Reef")
assert_eq(client.status_text(), "Joined as Mara of the Reef.")
func test_a_version_mismatch_is_refused_clearly() -> void:
var client: NetClient = NetClient.new()
client.protocol_version = NetProtocol.VERSION + 1
clients.append(client)
assert_eq(client.connect_to(HOST, server.port(), "Mara"), OK)
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED), client.state_name())
assert_eq(client.close_reason, NetProtocol.REASON_VERSION)
assert_eq(client.server_version, NetProtocol.VERSION)
var text: String = client.status_text()
assert_true(text.contains("older version") and text.contains("protocol %d" % NetProtocol.VERSION), text)
assert_eq(server.player_count(), 0)
assert_eq(_events("refused"), [{"type": "refused", "reason": NetProtocol.REASON_VERSION}] as Array[Dictionary])
assert_true(_events("joined").is_empty())
func test_a_full_server_says_so() -> void:
server.max_players = 2
var first: NetClient = _client("One")
var second: NetClient = _client("Two")
assert_true(_pump(func() -> bool: return first.state == NetClient.JOINED and second.state == NetClient.JOINED))
var third: NetClient = _client("Three")
assert_true(_pump(func() -> bool: return third.state == NetClient.CLOSED))
assert_eq(third.close_reason, NetProtocol.REASON_FULL)
assert_eq(third.status_text(), "The server is full.")
assert_eq(server.player_count(), 2)
# A place opens when someone leaves.
first.leave()
assert_true(_pump(func() -> bool: return server.player_count() == 1))
var fourth: NetClient = _client("Four")
assert_true(_pump(func() -> bool: return fourth.state == NetClient.JOINED))
assert_eq(fourth.handle, 3, "handles are never reused")
func test_duplicate_names_get_a_number() -> void:
var first: NetClient = _client("Mara")
assert_true(_pump(func() -> bool: return first.state == NetClient.JOINED))
var second: NetClient = _client("mara")
var third: NetClient = _client("Mara")
assert_true(_pump(func() -> bool: return second.state == NetClient.JOINED and third.state == NetClient.JOINED))
var names: Array[String] = [first.player_name, second.player_name, third.player_name]
names.sort()
assert_eq(names.size(), 3)
assert_true(names.has("Mara") and (names.has("mara 2") or names.has("Mara 2")), "names %s" % [names])
assert_ne(second.player_name.to_lower(), third.player_name.to_lower())
func test_a_clean_leave_is_seen_at_once() -> void:
server.peer_timeout_min_msec = 60000
server.peer_timeout_max_msec = 60000
var client: NetClient = _client("Mara")
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
client.leave()
assert_eq(client.state, NetClient.CLOSED)
assert_eq(client.close_reason, NetProtocol.REASON_LEFT)
assert_true(_pump(func() -> bool: return not _events("left").is_empty(), 2000), "the server heard the goodbye, not a timeout")
assert_eq(_events("left"), [{"type": "left", "handle": 1, "name": "Mara", "reason": NetProtocol.REASON_LEFT}] as Array[Dictionary])
assert_eq(server.player_count(), 0)
func test_a_client_that_vanishes_times_out() -> void:
server.close()
server.peer_timeout_min_msec = 300
server.peer_timeout_max_msec = 600
assert_eq(server.listen(0, HOST), OK)
var client: NetClient = _client("Mara")
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
# Pull the plug: no goodbye.
client._drop()
clients.clear()
assert_true(_pump(func() -> bool: return not _events("left").is_empty(), 8000), "the server noticed")
assert_eq(_events("left")[0]["reason"], NetProtocol.REASON_LOST)
assert_eq(server.player_count(), 0)
func test_a_silent_guest_is_dropped() -> void:
server.handshake_timeout_msec = 200
_raw()
var host: ENetConnection = raw_hosts[0]
assert_true(_pump(func() -> bool: return server.guest_count() == 1 or _raw_state[host]["disconnect_data"] >= 0))
assert_true(_pump(func() -> bool: return _raw_state[host]["disconnect_data"] >= 0), "the guest was disconnected")
assert_eq(_raw_state[host]["disconnect_data"], NetProtocol.REASON_HANDSHAKE_TIMEOUT)
assert_eq(NetProtocol.decode_reject(_raw_state[host]["packets"][0])["reason"], NetProtocol.REASON_HANDSHAKE_TIMEOUT)
assert_eq(server.guest_count(), 0)
assert_eq(server.player_count(), 0)
func test_malformed_handshakes_are_refused_and_the_server_carries_on() -> void:
var good: PackedByteArray = NetProtocol.encode_hello("Mara")
var huge: PackedByteArray = PackedByteArray()
huge.resize(60000)
huge.fill(0x41)
var wrong_magic: PackedByteArray = good.duplicate()
wrong_magic[1] = 0x00
var bad_name: PackedByteArray = good.slice(0, 7)
bad_name.append_array(PackedByteArray([2, 0xC3, 0x28]))
var packets: Array[PackedByteArray] = [
PackedByteArray([0]), PackedByteArray([NetProtocol.MSG_HELLO]), good.slice(0, 6), wrong_magic, huge, bad_name,
NetProtocol.encode_welcome(1, 1, 24, "Mara"), NetProtocol.encode_reject(NetProtocol.REASON_FULL),
]
for bytes: PackedByteArray in packets:
var peer: ENetPacketPeer = _raw()
peer.send(NetProtocol.CHANNEL_CONTROL, bytes, ENetPacketPeer.FLAG_RELIABLE)
# A good HELLO on the wrong channel is no handshake either.
var stray: ENetPacketPeer = _raw()
stray.send(NetProtocol.CHANNEL_STATE, good, ENetPacketPeer.FLAG_RELIABLE)
var expected: int = packets.size() + 1
assert_true(_pump(func() -> bool: return _events("refused").size() >= expected), "refused %d of %d" % [_events("refused").size(), expected])
for event: Dictionary in _events("refused"):
assert_eq(event["reason"], NetProtocol.REASON_BAD_HELLO)
assert_eq(server.bad_packets, expected)
assert_true(_pump(func() -> bool:
for host: ENetConnection in raw_hosts:
if _raw_state[host]["disconnect_data"] < 0:
return false
return true), "every bad peer was disconnected")
assert_eq(server.guest_count(), 0)
assert_eq(server.player_count(), 0)
# Still serving.
var client: NetClient = _client("Mara")
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
func test_random_packets_from_guests_and_players_never_crash_the_server() -> void:
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
rng.seed = 77
var member: NetClient = _client("Mara")
assert_true(_pump(func() -> bool: return member.state == NetClient.JOINED))
for _round: int in 12:
var peer: ENetPacketPeer = _raw()
for _packet: int in 6:
var bytes: PackedByteArray = PackedByteArray()
bytes.resize(rng.randi_range(0, 300))
for index: int in bytes.size():
bytes[index] = rng.randi_range(0, 255)
peer.send(rng.randi_range(0, 1), bytes, ENetPacketPeer.FLAG_RELIABLE)
# A player who keeps sending HELLOs and junk stays a player and changes nothing. The
# HELLOs are dropped; junk on the game channel goes to the owner, who can't read it.
for _packet: int in 20:
member._peer.send(NetProtocol.CHANNEL_CONTROL, NetProtocol.encode_hello("Someone Else"), ENetPacketPeer.FLAG_RELIABLE)
member._peer.send(NetProtocol.CHANNEL_STATE, PackedByteArray([1, 2, 3]), ENetPacketPeer.FLAG_RELIABLE)
assert_true(_pump(func() -> bool: return _events("refused").size() >= 12 and server.bad_packets >= 32 and handed >= 20), "refused %d, dropped %d, handed on %d" % [_events("refused").size(), server.bad_packets, handed])
assert_eq(handed, 20)
assert_eq(server.player_count(), 1)
assert_eq(server.name_of(1), "Mara")
assert_eq(_events("joined").size(), 1)
assert_eq(member.state, NetClient.JOINED)
func test_no_server_means_no_answer() -> void:
var port: int = server.port()
server.close()
var client: NetClient = NetClient.new()
client.connect_timeout_msec = 300
clients.append(client)
assert_eq(client.connect_to(HOST, port, "Mara"), OK)
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED, 3000))
assert_eq(client.close_reason, NetProtocol.REASON_NO_ANSWER)
assert_true(client.status_text().contains("No answer"))
func test_a_server_shutting_down_tells_its_players() -> void:
var client: NetClient = _client("Mara")
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
server.close()
assert_false(server.is_listening())
assert_eq(server.port(), 0)
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED))
assert_eq(client.close_reason, NetProtocol.REASON_SHUTDOWN)
assert_eq(client.status_text(), "The server shut down.")
func test_a_kicked_player_is_told_and_removed() -> void:
var client: NetClient = _client("Mara")
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
assert_true(server.kick(1))
assert_eq(server.events[-1], {"type": "left", "handle": 1, "name": "Mara", "reason": NetProtocol.REASON_KICKED})
assert_false(server.kick(1))
assert_eq(server.player_count(), 0)
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED))
assert_eq(client.close_reason, NetProtocol.REASON_KICKED)
assert_false(client.send(NetProtocol.CHANNEL_STATE, PackedByteArray([1]), false))
func test_two_servers_cannot_share_a_port() -> void:
var other: NetServer = NetServer.new()
expect_error("Couldn't create an ENet host")
assert_ne(other.listen(server.port(), HOST), OK)
assert_false(other.is_listening())
assert_true(server.is_listening())
func test_a_burst_of_connections_from_one_address_is_turned_away() -> void:
server.connect_limiter = SourceLimiter.new(3, 60000)
var burst: Array[NetClient] = []
for index: int in 5:
burst.append(_client("Wave %d" % index))
assert_true(_pump(func() -> bool:
var settled: int = 0
for client: NetClient in burst:
if client.state == NetClient.JOINED or client.state == NetClient.CLOSED:
settled += 1
return settled == burst.size()))
var joined: int = 0
for client: NetClient in burst:
if client.state == NetClient.JOINED:
joined += 1
else:
assert_eq(client.close_reason, NetProtocol.REASON_BUSY)
assert_eq(joined, 3)
assert_eq(server.player_count(), 3)
assert_true(NetProtocol.reason_text(NetProtocol.REASON_BUSY).begins_with("Too many connections"))
func test_handshakes_held_open_from_one_address_are_capped() -> void:
server.max_guests_per_address = 2
# Raw peers that connect and never say hello.
for _index: int in 4:
_raw()
assert_true(_pump(func() -> bool: return _events("refused").size() >= 2))
assert_eq(server.guest_count(), 2)
for event: Dictionary in _events("refused"):
assert_eq(event["reason"], NetProtocol.REASON_BUSY)
## N8: a server stopping with a grace sends its notice reliably, so clients behind a
## link that loses half its datagrams still hear it instead of timing out.
func test_a_graceful_shutdown_reaches_clients_on_a_lossy_link() -> void:
var relays: Array[UdpRelay] = []
var lossy: Array[NetClient] = []
for index: int in 4:
var relay: UdpRelay = UdpRelay.new(0.0, 0.0, 0.0, 11 + index)
assert_eq(relay.open(0, HOST, server.port()), OK)
relays.append(relay)
var client: NetClient = NetClient.new()
assert_eq(client.connect_to(HOST, relay.port(), "Lossy%d" % index), OK)
lossy.append(client)
var joined: Callable = func() -> bool:
for relay: UdpRelay in relays:
relay.poll()
for client: NetClient in lossy:
if client.state != NetClient.JOINED:
return false
return true
for _round: int in 2000:
server.poll()
for client: NetClient in lossy:
client.poll()
if joined.call():
break
OS.delay_msec(2)
assert_true(joined.call(), "every client joined")
for relay: UdpRelay in relays:
relay.loss = 0.5
# The clients go on being serviced in another thread while the server closes.
var stop: Array = [false]
var worker: Thread = Thread.new()
worker.start(func() -> void:
while not stop[0]:
for relay: UdpRelay in relays:
relay.poll()
for client: NetClient in lossy:
client.poll()
OS.delay_msec(2))
server.close(3000)
var started: int = Time.get_ticks_msec()
var all_closed: bool = false
while Time.get_ticks_msec() - started < 3000 and not all_closed:
OS.delay_msec(20)
all_closed = true
for client: NetClient in lossy:
all_closed = all_closed and client.state == NetClient.CLOSED
stop[0] = true
worker.wait_to_finish()
for client: NetClient in lossy:
assert_eq(client.state, NetClient.CLOSED)
assert_eq(client.close_reason, NetProtocol.REASON_SHUTDOWN, "%s was told the server stopped" % client.player_name)
for relay: UdpRelay in relays:
relay.close()
## H5: a peer that connects and then never answers again: it doesn't say hello, and
## doesn't acknowledge being turned away, so ENet alone would keep its slot for seconds.
func _silent(silent: Array[ENetConnection]) -> void:
var host: ENetConnection = ENetConnection.new()
assert_eq(host.create_host(1, NetProtocol.CHANNEL_COUNT), OK)
host.connect_to_host(HOST, server.port(), NetProtocol.CHANNEL_COUNT)
silent.append(host)
var connected: Array[bool] = [false]
_pump(func() -> bool:
var event: Array = host.service(0)
if event[0] == ENetConnection.EVENT_CONNECT:
connected[0] = true
return connected[0], 2000)
# The acknowledgement goes out on the next service; send it, then never again.
host.flush()
var before: int = server.guest_count() + _events("refused").size() + server.evicted
_pump(func() -> bool: return server.guest_count() + _events("refused").size() + server.evicted > before, 1000)
func _destroy(silent: Array[ENetConnection]) -> void:
for host: ENetConnection in silent:
host.destroy()
func test_a_flood_from_one_address_cannot_hold_the_slots() -> void:
server.close()
server.max_players = 2
server.peer_slots = 0
server.connect_limiter = SourceLimiter.new(3, 60000)
server.max_guests_per_address = 3
server.handshake_timeout_msec = 60000
assert_eq(server.listen(0, HOST), OK)
# Ten slots: three silent guests, then peers turned away for flooding.
var silent: Array[ENetConnection] = []
for _index: int in 9:
_silent(silent)
assert_eq(server.guest_count(), 3)
assert_eq(server.leaving_count(), 0, "peers turned away for flooding don't keep a slot")
assert_eq(_events("refused").size(), 6)
# The flood has passed; a real player still finds a slot.
server.connect_limiter = SourceLimiter.new(32, 10000)
server.max_guests_per_address = 8
var client: NetClient = _client("After")
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED or client.state == NetClient.CLOSED, 3000))
assert_eq(client.state, NetClient.JOINED)
_destroy(silent)
func test_silent_guests_make_room_for_a_newcomer() -> void:
server.close()
server.max_players = 2
server.peer_slots = 0
server.max_guests_per_address = 64
server.handshake_timeout_msec = 60000
assert_eq(server.listen(0, HOST), OK)
# More silent guests than the ten slots: the oldest make way, one slot stays free.
var silent: Array[ENetConnection] = []
for _index: int in 12:
_silent(silent)
assert_true(server.guest_count() <= 9, "a slot is kept free, %d guests" % server.guest_count())
assert_true(server.evicted >= 3)
var client: NetClient = _client("Newcomer")
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED or client.state == NetClient.CLOSED, 3000))
assert_eq(client.state, NetClient.JOINED)
assert_eq(server.player_count(), 1)
_destroy(silent)
func test_a_peer_that_never_acknowledges_leaving_is_cut_off() -> void:
server.close()
server.max_players = 2
server.handshake_timeout_msec = 100
server.leave_grace_msec = 300
assert_eq(server.listen(0, HOST), OK)
var silent: Array[ENetConnection] = []
_silent(silent)
assert_true(_pump(func() -> bool: return server.leaving_count() == 1, 2000), "the silent guest was told to go")
assert_true(_pump(func() -> bool: return server.leaving_count() == 0, 2000), "and cut off after its grace")
assert_eq(server.evicted, 1)
_destroy(silent)
## H5: a client turned away for flooding learns why from the disconnect alone.
func test_busy_reaches_the_client_without_a_reject_message() -> void:
assert_true(NetProtocol.is_server_reason(NetProtocol.REASON_BUSY))
assert_false(NetProtocol.is_server_reason(NetProtocol.REASON_NONE))
assert_false(NetProtocol.is_server_reason(NetProtocol.REASON_LOST))
server.connect_limiter = SourceLimiter.new(1, 60000)
var first: NetClient = _client("First")
var second: NetClient = _client("Second")
assert_true(_pump(func() -> bool: return second.state == NetClient.CLOSED and first.state == NetClient.JOINED))
assert_eq(second.close_reason, NetProtocol.REASON_BUSY)