extends TestCase ## Issue N9: a hostile client tries the usual cheats and every one fails. Its packets ## are crafted byte by byte, outside anything the real client would send, and go in ## through NetGame.take_input(), the same door a network packet uses, into a real ## match on a real island. The server trusts nothing in them but intent. const HOSTILE: int = 1 const VICTIM: int = 2 var loop: ServerLoop var game: NetGame var rng: RandomNumberGenerator func before_each() -> void: var rules: MatchRules = MatchRules.immediate() rules.max_players = 2 rules.min_players = 1 rules.fill_with_bots = false loop = ServerLoop.new(77, 2, 0, rules) game = NetGame.new(loop, NetServer.new()) game.adopt(HOSTILE) game.adopt(VICTIM) assert_true(loop.match_flow.in_match()) rng = RandomNumberGenerator.new() rng.seed = 1999 # Both off the ship and standing on level dry ground, as if they had landed. var spot: Vector3 = _level_spot() _stand(HOSTILE, spot) _stand(VICTIM, spot + Vector3(0.0, 0.0, 6.0)) func _player(handle: int) -> SimEntity: return loop.sim.entities.find(int(loop.match_flow.entity_of[handle])) func _stand(handle: int, at: Vector3) -> void: var player: SimEntity = _player(handle) player.drop_state = Drop.NONE player.position = at player.velocity = Vector3.ZERO player.on_ground = true ## A dry, level point well inland. func _level_spot() -> Vector3: var ground: SimGround = loop.sim.ground var centre: float = Tuning.WORLD_SIZE_METRES * 0.5 for ring: int in range(0, 400, 8): for step: int in 16: var angle: float = TAU * step / 16.0 var x: float = centre + cos(angle) * ring var z: float = centre + sin(angle) * ring var height: float = ground.terrain_height(x, z) if height < Tuning.ISLAND_BEACH_TOP + 6.0: continue var flat: bool = true for offset: Vector2 in [Vector2(8, 0), Vector2(-8, 0), Vector2(0, 8), Vector2(0, -8), Vector2(0, 14)]: if absf(ground.terrain_height(x + offset.x, z + offset.y) - height) > 0.6: flat = false if flat: return Vector3(x, height, z) fail("no level ground on this island") return Vector3.ZERO ## A command's 15 bytes with any value in any field, past what PlayerCommand.encode() ## would ever produce. func _raw_command(tick: int, move_x: int, move_y: int, yaw: int, pitch: int, buttons: int, selection: int, material: int, view_lag: int) -> PackedByteArray: var bytes: PackedByteArray = PackedByteArray() bytes.resize(PlayerCommand.ENCODED_SIZE) bytes.encode_u32(0, tick & 0xFFFFFFFF) bytes.encode_s8(4, move_x) bytes.encode_s8(5, move_y) bytes.encode_u16(6, yaw & 0xFFFF) bytes.encode_s16(8, pitch) bytes.encode_u16(10, buttons & 0xFFFF) bytes.encode_u8(12, selection & 0xFF) bytes.encode_u8(13, material & 0xFF) bytes.encode_u8(14, view_lag & 0xFF) return bytes func _packet(commands: Array[PackedByteArray]) -> PackedByteArray: var bytes: PackedByteArray = PackedByteArray([NetSnapshot.MSG_INPUT, 0, 0, 0, 0, commands.size()]) for command: PackedByteArray in commands: bytes.append_array(command) return bytes ## Sends the hostile packet for this tick, then runs it. func _tick(commands: Array[PackedByteArray]) -> void: game.take_input(HOSTILE, _packet(commands)) loop.run_tick() game.after_tick() func _horizontal(a: Vector3, b: Vector3) -> float: return Vector2(a.x - b.x, a.z - b.z).length() func test_speed_and_teleport_cheats_move_no_faster_than_sprinting() -> void: var player: SimEntity = _player(HOSTILE) var limit: float = Tuning.SPRINT_SPEED / Tuning.TICK_RATE_HZ + 0.001 var start: Vector3 = player.position var fastest: float = 0.0 var ticks: int = 150 for _index: int in ticks: var now: int = loop.sim.tick var commands: Array[PackedByteArray] = [] # The most extreme axes the bytes allow, sprint and jump, the same tick sent # several times with different contents, and every tick of the lead window # filled at once, as if the client could play ahead of the server. for copy: int in 3: commands.append(_raw_command(now + 1, -128, -128, 8192, 0, PlayerCommand.BUTTON_SPRINT | PlayerCommand.BUTTON_JUMP | 0xFE00, 0, 0, 255)) for ahead: int in range(2, NetSnapshot.MAX_INPUT_COMMANDS - 4): commands.append(_raw_command(now + ahead, -128 if ahead % 2 == 0 else 127, -128, 8192 * ahead, 0, 0xFFFF, 255, 255, 255)) # Ticks the server can never take: long past, far future, and the largest. commands.append(_raw_command(now - 500, 127, 127, 0, 0, 0xFFFF, 0, 0, 0)) commands.append(_raw_command(now + 10000, 127, 127, 0, 0, 0xFFFF, 0, 0, 0)) commands.append(_raw_command(0xFFFFFFFF, 127, 127, 0, 0, 0xFFFF, 0, 0, 0)) assert_eq(commands.size(), NetSnapshot.MAX_INPUT_COMMANDS) var before: Vector3 = player.position _tick(commands) fastest = maxf(fastest, _horizontal(player.position, before)) assert_true(fastest <= limit, "fastest step %.4f m against a limit of %.4f m" % [fastest, limit]) assert_true(_horizontal(player.position, start) <= limit * ticks) assert_true(_horizontal(player.position, start) > 1.0, "the cheater still moves: commands weren't simply refused") func test_a_packet_with_too_many_commands_is_refused_whole() -> void: var commands: Array[PackedByteArray] = [] for ahead: int in NetSnapshot.MAX_INPUT_COMMANDS + 1: commands.append(_raw_command(loop.sim.tick + 1 + ahead, 127, 127, 0, 0, 0, 0, 0, 0)) var bad: int = game.bad_inputs _tick(commands) assert_eq(game.bad_inputs, bad + 1) func test_a_far_future_command_does_not_lock_out_the_real_ones() -> void: var player: SimEntity = _player(HOSTILE) var start: Vector3 = player.position _tick([_raw_command(0xFFFFFFFF, 0, 0, 0, 0, 0, 0, 0, 0)] as Array[PackedByteArray]) for _index: int in 30: _tick([_raw_command(loop.sim.tick + 1, 0, 127, 0, 0, 0, 0, 0, 0)] as Array[PackedByteArray]) assert_true(_horizontal(player.position, start) > 1.0, "commands after a bogus far-future one are still taken") func test_rapid_fire_is_held_to_the_weapons_rate() -> void: var player: SimEntity = _player(HOSTILE) var code: int = ItemCatalog.code_of("dock_carbine") Inventory.give(player, code, 1) Inventory.give(player, ItemCatalog.get_def(code).ammo_code, 999) var interval: int = ItemCatalog.get_def(code).fire_interval_ticks() var shots: int = 0 var ticks: int = 240 for index: int in ticks: var now: int = loop.sim.tick # Fire pressed, released and pressed again within one tick's packet, fire on # every tick of the lead window, and a slot change every tick to try to skip # the cooldown. var commands: Array[PackedByteArray] = [] for ahead: int in range(1, mini(12, NetSnapshot.MAX_INPUT_COMMANDS + 1)): var buttons: int = PlayerCommand.BUTTON_FIRE if (index + ahead) % 2 == 0 else PlayerCommand.BUTTON_FIRE | PlayerCommand.BUTTON_AIM commands.append(_raw_command(now + ahead, 0, 0, 0, 0, buttons, 1 + (index % 2), 0, 255)) _tick(commands) for event: Dictionary in loop.sim.events: if event["type"] == "shot" and event["player"] == player.id: shots += 1 var most: int = ceili(float(ticks) / interval) + 1 assert_true(shots <= most, "%d shots in %d ticks; the weapon allows %d" % [shots, ticks, most]) func test_building_out_of_range_or_without_materials_fails() -> void: var player: SimEntity = _player(HOSTILE) for code: int in Materials.NAMES.size(): player.materials[code] = 0 var kinds: Array[int] = [StructureSet.WALL, StructureSet.FLOOR, StructureSet.RAMP, StructureSet.ROOF, StructureSet.BREAKWATER] # Without materials, nothing at all, whatever is claimed. for index: int in 60: _tick([_raw_command(loop.sim.tick + 1, 0, 0, rng.randi() & 0xFFFF, rng.randi_range(-32768, 32767), PlayerCommand.BUTTON_BUILD | PlayerCommand.BUTTON_FIRE, kinds[index % kinds.size()], rng.randi_range(0, 255), 255)] as Array[PackedByteArray]) assert_eq(loop.sim.structures.count(), 0, "nothing is built on credit") # With materials, every piece placed is within reach, whatever the aim, the kind # and material bytes, and the claimed lag. for code: int in Materials.NAMES.size(): player.materials[code] = 999 var placed: int = 0 var farthest: float = 0.0 for index: int in 300: var eye: Vector3 = Harvest.eye(player) # Half the time a real kind and material, so pieces do get placed. var honest: bool = index % 2 == 0 var kind: int = kinds[rng.randi_range(0, kinds.size() - 1)] if honest else rng.randi_range(0, 255) var material: int = rng.randi_range(0, Materials.NAMES.size() - 1) if honest else rng.randi_range(0, 255) _tick([_raw_command(loop.sim.tick + 1, rng.randi_range(-128, 127), rng.randi_range(-128, 127), rng.randi() & 0xFFFF, rng.randi_range(-32768, 32767), PlayerCommand.BUTTON_BUILD | PlayerCommand.BUTTON_FIRE, kind, material, 255)] as Array[PackedByteArray]) for event: Dictionary in loop.sim.events: if event["type"] != "piece_placed": continue placed += 1 assert_true(int(event["material"]) < Materials.NAMES.size()) var piece: StructureSet.Piece = loop.sim.structures.find(int(event["piece"])) var nearest: float = INF for box: AABB in piece.boxes: var closest: Vector3 = eye.clamp(box.position, box.end) nearest = minf(nearest, closest.distance_to(eye)) farthest = maxf(farthest, nearest) assert_true(placed > 0, "honest-looking build commands among the noise still build") assert_true(farthest <= Tuning.BUILD_RANGE + 0.01, "a piece %.2f m away; reach is %.2f m" % [farthest, Tuning.BUILD_RANGE]) ## Everything of every kind, carried and on the ground. Rounds in magazines aren't ## counted; nothing here fires or reloads. func _all_items() -> Dictionary: var totals: Dictionary = {} var sim: Simulation = loop.sim for handle: int in [HOSTILE, VICTIM]: var player: SimEntity = _player(handle) for slot: int in Inventory.slot_count(): if player.slot_items[slot] != Inventory.EMPTY: totals[player.slot_items[slot]] = int(totals.get(player.slot_items[slot], 0)) + player.slot_counts[slot] for index: int in player.ammo.size(): var ammo_code: int = Inventory.ammo_code(index) totals[ammo_code] = int(totals.get(ammo_code, 0)) + player.ammo[index] for pickup_id: int in sim.pickups: var pickup: SimEntity = sim.entities.find(pickup_id) totals[pickup.item] = int(totals.get(pickup.item, 0)) + pickup.item_count for code: int in totals.keys(): if totals[code] == 0: totals.erase(code) return totals func test_item_duplication_tricks_create_nothing() -> void: var player: SimEntity = _player(HOSTILE) # A few things to juggle, at the cheater's feet and in hand. for id: String in ["dock_carbine", "signal_revolver"]: Inventory.spawn_pickup(loop.sim, player.position, ItemCatalog.code_of(id), 1) Inventory.give(player, ItemCatalog.code_of("dock_carbine"), 1) var before: Dictionary = _all_items() var tricks: Array[int] = [ PlayerCommand.BUTTON_INTERACT, PlayerCommand.BUTTON_DROP, PlayerCommand.BUTTON_INTERACT | PlayerCommand.BUTTON_DROP, PlayerCommand.BUTTON_DROP | PlayerCommand.BUTTON_BUILD, PlayerCommand.BUTTON_INTERACT | PlayerCommand.BUTTON_CROUCH, 0, ] for index: int in 600: var now: int = loop.sim.tick var commands: Array[PackedByteArray] = [] # The same tick claimed over and over with different buttons and slots, and # selections outside the inventory. for copy: int in rng.randi_range(1, 6): var buttons: int = tricks[rng.randi_range(0, tricks.size() - 1)] var ahead: int = 1 if copy < 3 else rng.randi_range(1, 4) commands.append(_raw_command(now + ahead, rng.randi_range(-4, 4), rng.randi_range(-4, 4), rng.randi() & 0xFFFF, 0, buttons, rng.randi_range(0, 255), 0, rng.randi_range(0, 255))) _tick(commands) # Lying in the same place keeps things in reach. if _horizontal(player.position, _player(VICTIM).position) > 20.0: player.position = _player(VICTIM).position - Vector3(0.0, 0.0, 6.0) assert_eq(_all_items(), before, "items were neither made nor lost")