From 59a37277f2ca6bbb29cb8e8af2eee079d5ae6e9d Mon Sep 17 00:00:00 2001 From: TMC Date: Mon, 16 Nov 2026 11:22:17 +0100 Subject: [PATCH] Limit what one address can do, and close idle rooms Someone scripting the server could guess the 4-character room codes without limit (one connection, thousands a second), open all 2000 rooms in seconds, or flood it with connections and messages. Per IP address now: - 10 wrong room codes in a row, then one a minute; while cut off even a right code gets no answer. Coming back to your seat with a token is not limited, and answers the same whether the room or the seat is gone, so it tells nothing about which codes are in use. - 10 new rooms in a row, then one every 3 minutes. - 32 connections at a time; 40 messages in a burst, then 10 a second. The address comes from X-Forwarded-For only when the connection is from the local or Docker network (the TLS proxy); the server warns once if such connections arrive without the header. A room where no player did anything for 3 hours now closes even with screens still connected (a forgotten tab), telling them why. Rooms nobody is connected to already closed after 10 minutes. Co-Authored-By: Claude Opus 5.5 --- README.md | 11 ++ .../src/main/kotlin/hr/bela/server/Limits.kt | 108 ++++++++++++ server/src/main/kotlin/hr/bela/server/Main.kt | 79 ++++++++- server/src/main/kotlin/hr/bela/server/Room.kt | 22 ++- .../main/kotlin/hr/bela/server/RoomStore.kt | 6 +- .../test/kotlin/hr/bela/server/ServerTest.kt | 161 +++++++++++++++++- 6 files changed, 375 insertions(+), 12 deletions(-) create mode 100644 server/src/main/kotlin/hr/bela/server/Limits.kt diff --git a/README.md b/README.md index e748f86..a0c380c 100644 --- a/README.md +++ b/README.md @@ -82,6 +82,17 @@ Ponovno pokretanje servera (nova verzija, restart računala) ne prekida partije. - Spremanje i učitavanje: `server/.../RoomStore.kt` (datoteka), `Rooms.kt` (kada), `Room.kt` (`snapshot`, `restore`). Partija se sprema kao sjeme i popis poteza (`GameRecord`, isti zapis kao spremljena lokalna igra) i ponovno odigra pri učitavanju. - Ako se pravila u novoj verziji promijene tako da se stara partija ne može ponovno odigrati, soba ostaje, ali bez partije: igrači se vrate u čekaonicu i domaćin pokrene novu. +Soba nestaje kad je svi napuste, 10 minuta nakon što se posljednji igrač odspoji, ili nakon 3 sata u kojima nitko od igrača ništa nije odigrao ni kliknuo, čak i kad im je stranica otvorena (`Timing.idleClose`). Tada spojenim igračima javi da je soba zatvorena. + +Zaštita od skripti (`server/.../Limits.kt`), po IP adresi: + +- **Pogađanje kodova:** nakon 10 pogrešnih kodova adresa može pokušati još jedan kod u minuti. Dok je blokirana, ne dobiva odgovor ni za točan kod, pa joj pogađanje ne koristi. Povratak na svoje mjesto (token) nije ograničen. Taj povratak na nepostojeću sobu i povratak s krivim tokenom dobivaju isti odgovor, tako da ni preko toga ne može doznati koji su kodovi zauzeti. +- **Otvaranje soba:** 10 soba zaredom, zatim jedna svake 3 minute. Ukupno je dopušteno najviše 2000 otvorenih soba. +- **Veze:** najviše 32 istodobne veze s jedne adrese. +- **Poruke:** 40 poruka odjednom, zatim 10 u sekundi po vezi. Kad veza to prijeđe, server je prekine. + +Server uzima adresu iz `X-Forwarded-For` samo kad veza dolazi s lokalne ili Docker mreže, odnosno od proxyja. Ako proxy ne šalje `X-Forwarded-For`, svi igrači izgledaju kao jedna adresa i dijele ograničenja. Server to jednom upozori u logu (`Connections come from … without X-Forwarded-For`). + ## Server, Docker i Gitea Actions Jedna Docker slika (`Dockerfile`) gradi web i server (uz testove) i pokreće server koji poslužuje web na `/`, igru na `/ws` i `/health`. Gitea Actions (`.gitea/workflows/release.yml`, isto kao Keep) na svaki push na `main` gradi sliku, skenira je Trivyjem i objavljuje kao `git.mariosem.es/msemes/bela:` i `:latest`. Za objavu repozitorij treba tajnu `REGISTRY_TOKEN` (osobni token s `write:package`). diff --git a/server/src/main/kotlin/hr/bela/server/Limits.kt b/server/src/main/kotlin/hr/bela/server/Limits.kt new file mode 100644 index 0000000..bb61b0b --- /dev/null +++ b/server/src/main/kotlin/hr/bela/server/Limits.kt @@ -0,0 +1,108 @@ +package hr.bela.server + +import java.net.Inet6Address +import java.net.InetAddress + +/** + * How much one client may do, against someone scripting the server: guessing room codes, opening rooms by the + * hundred, or flooding it with connections and messages. Generous enough that people playing never notice. + * "Address" is the client's IP address ([clientAddress]). + */ +data class Limits( + /** Wrong room codes an address may try in a row; after that one more every [wrongCodeEvery] ms. */ + val wrongCodes: Int = 10, + val wrongCodeEvery: Long = 60_000L, + /** Rooms an address may open in a row; after that one more every [newRoomEvery] ms. */ + val newRooms: Int = 10, + val newRoomEvery: Long = 3 * 60_000L, + /** Connections open at the same time from one address (a whole office or family shares one). */ + val connections: Int = 32, + /** Messages a connection may send in a burst; after that one more every [messageEvery] ms. */ + val messageBurst: Int = 40, + val messageEvery: Long = 100L, +) + +/** + * A token bucket per key: [capacity] tokens, one more every [every] ms. Full buckets are forgotten, so the map + * only holds the keys that used it lately. + */ +class RateLimiter( + private val capacity: Int, + private val every: Long, + private val clock: () -> Long = System::currentTimeMillis, +) { + private class Bucket(var tokens: Double, var at: Long) + + private val buckets = HashMap() + private var calls = 0 + + /** Whether [key] has a token left, without taking it. */ + @Synchronized + fun allows(key: String): Boolean = level(key, clock()) >= 1 + + /** Takes one of [key]'s tokens; false (and nothing taken) when it has none left. */ + @Synchronized + fun take(key: String): Boolean { + val now = clock() + val tokens = level(key, now) + if (tokens < 1) return false + buckets[key] = Bucket(tokens - 1, now) + if (++calls % 1024 == 0) buckets.entries.removeAll { level(it.value, now) >= capacity } + return true + } + + private fun level(key: String, now: Long): Double = buckets[key]?.let { level(it, now) } ?: capacity.toDouble() + + private fun level(bucket: Bucket, now: Long): Double = + minOf(capacity.toDouble(), bucket.tokens + (now - bucket.at).toDouble() / every) +} + +/** Open connections per address, at most [max] each. */ +class ConnectionCounter(private val max: Int) { + private val open = HashMap() + + /** Counts a new connection from [key]; false (and not counted) when [key] already has [max]. */ + @Synchronized + fun open(key: String): Boolean { + val count = open[key] ?: 0 + if (count >= max) return false + open[key] = count + 1 + return true + } + + @Synchronized + fun close(key: String) { + val count = open[key] ?: return + if (count <= 1) open.remove(key) else open[key] = count - 1 + } +} + +/** + * The client's IP address: the one the connection comes from, or, when that is a proxy on this machine or the local + * network (the TLS front end), the address the proxy saw, which it adds last to X-Forwarded-For. A client connecting + * from the internet straight to the port cannot choose its address by sending the header itself. + */ +fun clientAddress(peer: String, forwardedFor: String?): String { + val forwarded = forwardedFor?.substringAfterLast(',')?.trim()?.takeIf { it.isNotEmpty() } ?: return peer + return if (isLocal(peer)) forwarded else peer +} + +/** + * A connection from another machine on the local network (or a Docker network) without X-Forwarded-For: most likely + * a proxy that does not send it, so every player looks like the proxy and they all share one address's [Limits]. + */ +fun proxyWithoutForwardedFor(peer: String, forwardedFor: String?): Boolean = + forwardedFor.isNullOrBlank() && isLocal(peer) && peer != "localhost" && + runCatching { !InetAddress.getByName(peer.substringBefore('%')).isLoopbackAddress }.getOrDefault(false) + +private fun isLocal(address: String): Boolean { + if (address == "localhost") return true + val literal = address.substringBefore('%') + // A literal address only (IPv4, or IPv6 with its colons): a name would be looked up. + if (!literal.matches(IPV4) && !(':' in literal && literal.all { it.isLetterOrDigit() || it in ".:" })) return false + val ip = runCatching { InetAddress.getByName(literal) }.getOrNull() ?: return false + return ip.isLoopbackAddress || ip.isSiteLocalAddress || ip.isLinkLocalAddress || + (ip is Inet6Address && (ip.address[0].toInt() and 0xfe) == 0xfc) +} + +private val IPV4 = Regex("""\d{1,3}(\.\d{1,3}){3}""") diff --git a/server/src/main/kotlin/hr/bela/server/Main.kt b/server/src/main/kotlin/hr/bela/server/Main.kt index 23d9268..4554734 100644 --- a/server/src/main/kotlin/hr/bela/server/Main.kt +++ b/server/src/main/kotlin/hr/bela/server/Main.kt @@ -21,13 +21,17 @@ import io.ktor.server.websocket.WebSockets import io.ktor.server.websocket.pingPeriod import io.ktor.server.websocket.timeout import io.ktor.server.websocket.webSocket +import io.ktor.websocket.CloseReason +import io.ktor.websocket.DefaultWebSocketSession import io.ktor.websocket.Frame +import io.ktor.websocket.close import io.ktor.websocket.readText import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.withTimeoutOrNull import org.slf4j.LoggerFactory import org.slf4j.event.Level import java.io.File +import java.util.concurrent.atomic.AtomicBoolean import kotlin.time.Duration.Companion.seconds /** @@ -45,12 +49,18 @@ fun main() { embeddedServer(Netty, port = port) { bela(webRoot, store = store) }.start(wait = true) } -fun Application.bela(webRoot: File?, timing: Timing = Timing(), store: RoomStore? = null) { +fun Application.bela(webRoot: File?, timing: Timing = Timing(), store: RoomStore? = null, limits: Limits = Limits()) { val log = LoggerFactory.getLogger("bela") if (store == null) log.info("No DATA_DIR: open rooms will not survive a restart") else log.info("Open rooms are kept in {}", store.file) // Loaded here, before the server takes connections, so returning players find their rooms. val rooms = Rooms(this, timing, store = store) monitor.subscribe(ApplicationStopping) { rooms.stop() } + val wrongCodes = RateLimiter(limits.wrongCodes, limits.wrongCodeEvery) + val newRooms = RateLimiter(limits.newRooms, limits.newRoomEvery) + val connections = ConnectionCounter(limits.connections) + val proxyWarned = AtomicBoolean(false) + // A warning about an address at most once a minute, so someone scripting the server cannot fill the log. + val warnings = RateLimiter(1, 60_000L) install(CallLogging) { level = Level.INFO @@ -66,12 +76,35 @@ fun Application.bela(webRoot: File?, timing: Timing = Timing(), store: RoomStore get("/health") { call.respondText("ok") } webSocket("/ws") { + val peer = call.request.local.remoteAddress + val forwardedFor = call.request.headers["X-Forwarded-For"] + if (proxyWithoutForwardedFor(peer, forwardedFor) && proxyWarned.compareAndSet(false, true)) { + log.warn( + "Connections come from {} without X-Forwarded-For: all players count as one address for the " + + "limits on connections and room codes. Let the proxy in front send X-Forwarded-For.", + peer, + ) + } + val address = clientAddress(peer, forwardedFor) + if (!connections.open(address)) { + if (warnings.take("connections $address")) log.warn("Too many connections from {}; refused", address) + sendNow(ServerMessage.Error(TOO_MANY_CONNECTIONS, fatal = true)) + close(CloseReason(CloseReason.Codes.TRY_AGAIN_LATER, "Too many connections")) + return@webSocket + } val connection = Connection(this) + val messages = RateLimiter(limits.messageBurst, limits.messageEvery) var room: Room? = null var member: Member? = null try { for (frame in incoming) { if (frame !is Frame.Text) continue + if (!messages.take("")) { + if (warnings.take("messages $address")) log.warn("{} sends too many messages; disconnected", address) + // Straight away: the socket closes when this loop ends, before the queue would be sent. + sendNow(ServerMessage.Error("Previše poruka odjednom. Spoji se ponovno.", fatal = true)) + break + } val message = try { Protocol.json.decodeFromString(ClientMessage.serializer(), frame.readText()) } catch (_: Exception) { @@ -106,11 +139,38 @@ fun Application.bela(webRoot: File?, timing: Timing = Timing(), store: RoomStore connection.send(ServerMessage.Error("Upiši svoje ime.")) continue } - val target = if (entry.code == null) rooms.create() else rooms[entry.code] - if (target == null) { - val text = if (entry.code == null) "Poslužitelj je trenutno pun, pokušaj kasnije." else "Soba ${entry.code} ne postoji." - connection.send(ServerMessage.Error(text, fatal = true)) - continue + val target = when { + entry.code == null -> { + if (!newRooms.take(address)) { + if (warnings.take("rooms $address")) log.warn("{} opens too many rooms", address) + connection.send(ServerMessage.Error("Otvorio si previše soba zaredom. Pričekaj par minuta.", fatal = true)) + continue + } + rooms.create() ?: run { + connection.send(ServerMessage.Error("Poslužitelj je trenutno pun, pokušaj kasnije.", fatal = true)) + continue + } + } + // Coming back with a token: one answer whether the room or the seat is gone, so a made-up + // token tells nothing about which codes are in use. Tokens cannot be guessed. + entry.token != null -> rooms[entry.code] ?: run { + connection.send(ServerMessage.Error("Tvoje mjesto u sobi ${entry.code} je isteklo.", fatal = true)) + continue + } + // Joining by code: an address that keeps guessing codes is cut off for a while, and then even + // a right code gets no answer, so the guessing is no use. + !wrongCodes.allows(address) -> { + connection.send(ServerMessage.Error("Previše pogrešnih kodova. Pričekaj minutu pa pokušaj ponovno.", fatal = true)) + continue + } + else -> rooms[entry.code] ?: run { + wrongCodes.take(address) + if (!wrongCodes.allows(address) && warnings.take("codes $address")) { + log.warn("{} tried too many wrong room codes; cut off for a while", address) + } + connection.send(ServerMessage.Error("Soba ${entry.code} ne postoji.", fatal = true)) + continue + } } val reply = CompletableDeferred() val joined = target.post(Room.Event.Enter(connection, entry.name, entry.token, reply)) && @@ -126,6 +186,7 @@ fun Application.bela(webRoot: File?, timing: Timing = Timing(), store: RoomStore val m = member if (m != null) room?.post(Room.Event.Gone(m, connection)) connection.close() + connections.close(address) } } @@ -157,6 +218,12 @@ fun Application.bela(webRoot: File?, timing: Timing = Timing(), store: RoomStore } } +/** Sends [message] now, not through the [Connection]'s queue. */ +private suspend fun DefaultWebSocketSession.sendNow(message: ServerMessage) = + send(Frame.Text(Protocol.json.encodeToString(ServerMessage.serializer(), message))) + +private const val TOO_MANY_CONNECTIONS = "Previše je veza s tvoje mreže. Pokušaj ponovno kasnije." + private const val OUTDATED = "Ova verzija Bele je zastarjela za igru online. Ažuriraj aplikaciju ili osvježi stranicu." /** What a create, join or resume message asks for: [code] null creates a room; [token] set resumes a seat. */ diff --git a/server/src/main/kotlin/hr/bela/server/Room.kt b/server/src/main/kotlin/hr/bela/server/Room.kt index 8c779ab..76e2577 100644 --- a/server/src/main/kotlin/hr/bela/server/Room.kt +++ b/server/src/main/kotlin/hr/bela/server/Room.kt @@ -38,6 +38,11 @@ data class Timing( val botTakeover: Long = 10_000L, /** A player away for this long loses their seat (a bot keeps playing it meanwhile). */ val dropAfter: Long = 10 * 60_000L, + /** + * A room where none of the players did anything for this long closes, even with their screens still connected + * (a tab left open): a forgotten room should not live for days. + */ + val idleClose: Long = 3 * 3600_000L, val sweepEvery: Long = 30_000L, /** After a restart, players get this long to reconnect before bots play their seats. */ val restoreGrace: Long = 30_000L, @@ -109,6 +114,9 @@ class Room( private var plannedFor: GameState? = null private var plannedAt = 0L private var generation = 0 + + /** When a player last joined or did something here ([Timing.idleClose]); bots do not count. */ + private var lastActive = clock() private var closed = false private val sweeper: Job @@ -140,6 +148,7 @@ class Room( when (event) { is Event.Enter -> enter(event) is Event.Message -> if (event.member.connection === event.connection && event.member in members) { + lastActive = clock() message(event.member, event.message) } is Event.Gone -> gone(event.member, event.connection) @@ -183,6 +192,7 @@ class Room( } } member.connection = connection + lastActive = clock() event.reply.complete(member) connection.send(ServerMessage.Joined(code, member.token)) sendRoom() @@ -217,9 +227,17 @@ class Room( schedule() } - /** Drops players who have been away too long; closes the room when nobody is left. */ + /** Drops players who have been away too long; closes the room when nobody is left, or nobody plays any more. */ private fun sweep() { val now = clock() + if (now - lastActive > timing.idleClose) { + log.info("Nothing happened for {} min", (now - lastActive) / 60_000) + for (member in members) { + member.connection?.send(ServerMessage.Error("Soba $code je zatvorena jer se u njoj dugo ništa nije događalo.", fatal = true)) + } + members.clear() + return close() + } members.filter { it.connection == null && now - it.awaySince > timing.dropAfter }.forEach(::leave) if (members.isEmpty()) close() } @@ -367,6 +385,7 @@ class Room( members = members.map { SavedMember(it.token, it.name, it.seat, if (it.connection == null) it.awaySince else 0) }, host = host?.token, game = record?.encode(), + lastActive = lastActive, ) private fun restore(saved: SavedRoom) { @@ -383,6 +402,7 @@ class Room( game = record?.let { runCatching { it.replay() }.onFailure { e -> log.warn("Game not restored: {}", e.message) }.getOrNull() } this.record = record.takeIf { game != null } graceUntil = now + timing.restoreGrace + if (saved.lastActive > 0) lastActive = saved.lastActive log.info("Restored with {} player(s){}", members.size, if (game != null) ", game in progress" else "") } diff --git a/server/src/main/kotlin/hr/bela/server/RoomStore.kt b/server/src/main/kotlin/hr/bela/server/RoomStore.kt index 0b79281..a6014bc 100644 --- a/server/src/main/kotlin/hr/bela/server/RoomStore.kt +++ b/server/src/main/kotlin/hr/bela/server/RoomStore.kt @@ -11,13 +11,17 @@ import java.nio.file.StandardCopyOption @Serializable data class SavedMember(val token: String, val name: String, val seat: Int, val awaySince: Long = 0) -/** A room as saved: its people, the host (by token) and the game so far ([hr.bela.engine.GameRecord.encode]). */ +/** + * A room as saved: its people, the host (by token), the game so far ([hr.bela.engine.GameRecord.encode]) and when a + * player last did something (0: unknown, from an older save). + */ @Serializable data class SavedRoom( val code: String, val members: List, val host: String? = null, val game: String? = null, + val lastActive: Long = 0, ) @Serializable diff --git a/server/src/test/kotlin/hr/bela/server/ServerTest.kt b/server/src/test/kotlin/hr/bela/server/ServerTest.kt index e6a0f1a..413eb6e 100644 --- a/server/src/test/kotlin/hr/bela/server/ServerTest.kt +++ b/server/src/test/kotlin/hr/bela/server/ServerTest.kt @@ -32,11 +32,26 @@ import kotlin.test.assertTrue class ServerTest { private val fast = Timing(dealPause = 0, bidDelay = 1, playDelay = 1, trickPause = 0, trumpPause = 0) - private fun serverTest(block: suspend ApplicationTestBuilder.() -> Unit) = testApplication { - application { bela(webRoot = null, timing = fast) } + /** The test players play at machine speed, far more messages a second than a person sends. */ + private val machineSpeed = Limits(messageEvery = 1) + + private fun serverTest( + timing: Timing = fast, + limits: Limits = machineSpeed, + block: suspend ApplicationTestBuilder.() -> Unit, + ) = testApplication { + application { bela(webRoot = null, timing = timing, limits = limits) } block() } + /** The next error, skipping everything else. */ + private suspend fun DefaultClientWebSocketSession.expectError(): ServerMessage.Error { + while (true) { + val message = receive() + if (message is ServerMessage.Error) return message + } + } + private suspend fun DefaultClientWebSocketSession.send(message: ClientMessage) = send(Frame.Text(Protocol.json.encodeToString(ClientMessage.serializer(), message))) @@ -175,7 +190,7 @@ class ServerTest { var token = "" var before: TableView? = null testApplication { - application { bela(webRoot = null, timing = fast, store = store) } + application { bela(webRoot = null, timing = fast, store = store, limits = machineSpeed) } val ws = createClient { install(WebSockets) } ws.webSocket("/ws") { send(ClientMessage.CreateRoom("Ana")) @@ -198,7 +213,7 @@ class ServerTest { } // the server stops (a new release): the rooms are written to the store assertTrue(store.file.exists()) testApplication { - application { bela(webRoot = null, timing = fast, store = store) } + application { bela(webRoot = null, timing = fast, store = store, limits = machineSpeed) } val ws = createClient { install(WebSockets) } ws.webSocket("/ws") { send(ClientMessage.Resume(code, token)) @@ -211,6 +226,144 @@ class ServerTest { } } + @Test + fun guessingRoomCodesIsCutOff() = serverTest(limits = Limits(wrongCodes = 3, wrongCodeEvery = 3_600_000)) { + val ws = createClient { install(WebSockets) } + val joined = CompletableDeferred() + val guessed = CompletableDeferred() + coroutineScope { + val host = async { + ws.webSocket("/ws") { + send(ClientMessage.CreateRoom("Ana")) + joined.complete(expect()) + guessed.await() + } + } + val (code, token) = joined.await().let { it.code to it.token } + ws.webSocket("/ws") { + for (guess in listOf("AAAA", "BBBB", "CCCC", "DDDD").filter { it != code }.take(3)) { + send(ClientMessage.JoinRoom(guess, "Ivo")) + assertTrue("ne postoji" in assertIs(receive()).message) + } + // Cut off: now even the right code gets no answer. + send(ClientMessage.JoinRoom(code, "Ivo")) + val error = assertIs(receive()) + assertTrue(error.fatal && "Previše pogrešnih kodova" in error.message, error.message) + // A player coming back to their own seat is not held up by it. + send(ClientMessage.Resume(code, token)) + assertEquals(code, expect().code) + } + guessed.complete(Unit) + host.await() + } + } + + @Test + fun openingRoomsIsLimited() = serverTest(limits = Limits(newRooms = 2, newRoomEvery = 3_600_000)) { + val ws = createClient { install(WebSockets) } + ws.webSocket("/ws") { + send(ClientMessage.CreateRoom("Ana")) + expect() + send(ClientMessage.CreateRoom("Ana")) + expect() + send(ClientMessage.CreateRoom("Ana")) + val error = expectError() + assertTrue(error.fatal && "previše soba" in error.message, error.message) + } + } + + @Test + fun aComebackAfterTheRoomClosedSaysTheSeatExpired() = serverTest { + val ws = createClient { install(WebSockets) } + ws.webSocket("/ws") { + send(ClientMessage.Resume("ZZZZ", "not-a-token")) + val error = assertIs(receive()) + assertTrue(error.fatal && "isteklo" in error.message, error.message) + } + } + + @Test + fun aRoomWhereNothingHappensCloses() = serverTest(timing = fast.copy(idleClose = 300, sweepEvery = 100)) { + val ws = createClient { install(WebSockets) } + ws.webSocket("/ws") { + send(ClientMessage.CreateRoom("Ana")) + val code = expect().code + val error = withTimeout(10_000) { expectError() } + assertTrue(error.fatal && "zatvorena" in error.message, error.message) + send(ClientMessage.JoinRoom(code, "Ana")) + assertTrue("ne postoji" in expectError().message, "the room is gone") + } + } + + @Test + fun aClientFloodingMessagesIsDisconnected() = serverTest(limits = Limits(messageBurst = 5, messageEvery = 3_600_000)) { + val ws = createClient { install(WebSockets) } + ws.webSocket("/ws") { + send(ClientMessage.CreateRoom("Ana")) + expect() + repeat(10) { send(ClientMessage.TakeSeat(0)) } + val error = expectError() + assertTrue(error.fatal && "Previše poruka" in error.message, error.message) + } + } + + @Test + fun tooManyConnectionsFromOneAddressAreRefused() = serverTest(limits = Limits(connections = 1)) { + val ws = createClient { install(WebSockets) } + val first = CompletableDeferred() + val done = CompletableDeferred() + coroutineScope { + val open = async { + ws.webSocket("/ws") { + send(ClientMessage.CreateRoom("Ana")) + expect() + first.complete(Unit) + done.await() + } + } + first.await() + ws.webSocket("/ws") { + val error = assertIs(receive()) + assertTrue(error.fatal && "Previše je veza" in error.message, error.message) + } + done.complete(Unit) + open.await() + } + // The first one closed, so there is room for another. + ws.webSocket("/ws") { + send(ClientMessage.CreateRoom("Ana")) + expect() + } + } + + @Test + fun theProxysAddressIsTrustedOnlyFromTheLocalNetwork() { + assertEquals("203.0.113.7", clientAddress("203.0.113.7", null)) + assertEquals("203.0.113.7", clientAddress("203.0.113.7", "198.51.100.1"), "straight from the internet: the header is ignored") + assertEquals("198.51.100.2", clientAddress("172.18.0.2", "10.0.0.5, 198.51.100.2"), "behind the proxy: the address it saw") + assertEquals("198.51.100.2", clientAddress("127.0.0.1", "198.51.100.2")) + assertEquals("198.51.100.2", clientAddress("::1", "198.51.100.2")) + assertEquals("example.com", clientAddress("example.com", "198.51.100.2"), "a name is never looked up") + assertTrue(proxyWithoutForwardedFor("172.17.0.1", null), "the Docker gateway without the header") + assertFalse(proxyWithoutForwardedFor("172.17.0.1", "198.51.100.2")) + assertFalse(proxyWithoutForwardedFor("127.0.0.1", null), "a local test run") + assertFalse(proxyWithoutForwardedFor("203.0.113.7", null), "a player straight from the internet") + } + + @Test + fun rateLimiterRefills() { + var now = 0L + val limiter = RateLimiter(capacity = 2, every = 1_000, clock = { now }) + assertTrue(limiter.take("a") && limiter.take("a")) + assertFalse(limiter.take("a")) + assertTrue(limiter.take("b"), "each key has its own bucket") + now = 999 + assertFalse(limiter.allows("a")) + now = 1_000 + assertTrue(limiter.take("a")) + assertFalse(limiter.take("a")) + } + @Test fun anUnreadableStoreIsSetAside() { val store = RoomStore(File(Files.createTempDirectory("bela").toFile(), "rooms.json"))