kurogai level 1.1

Overview

Inspiration was taken from kurogai 100 redteam projects, please check out their challenges!

Level 1.1

TCP chat server

The description of this level is pretty vague. It doesn’t seem like the program should be multi-threaded since that is meant for Level 4. From what I gather, the only way for this program to work without multi-threading or asynchronous programming is to either store a client message, and send it to every host who has previously connected to the server, but that would mean that I would have to re-initiate a TCP connection with all of those hosts to send the data, but that would require three things:

• that the server stores information about the previously connected clients (IP address)
• the clients would have to be listening for incoming connections with an open stream socket
  • “open stream socket” -> a an open socket that happens to be a stream socket; e.g., sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM); sock.listen(), as seen in python. This is pretty standard for a TCP socket (a.k.a., a stream socket, because TCP is a stream protocol)
• the server knows what port the clients are listening for TCP connections on

Even if the server had all of this information, such a program would be pretty inefficient, and honestly pretty bad.

I will go with the asynchronous approach, which is distinct from multi-threading. Here are my reasons:

• depending on the purpose of the application, asynchronous programming can be the superior choice
  • in my experience, it really shines when doing multiple instances of an IO-bound task, like reading data over a network (e.g., reading data over a TCP connection)
  • in the sequential approach (or the “blocking” approach), I would have to wait for the data to finish reading before I can do anything else, but with asynchronous programming, I can do other stuff concurrently

Here is some good reading:

• https://wiki.python.org/moin/GlobalInterpreterLock
• https://www.geeksforgeeks.org/synchronous-and-asynchronous-programming/
• https://medium.com/@moraneus/mastering-pythons-asyncio-a-practical-guide-0a673265cf04

Fun fact, there are several models for asynchronous programming. Some of the more popular ones are event-driven, task-based, and callback-based. The specific model of async usually depends on the language. Python uses TAP (Task-based asynchronous programming).

Solution

import asyncio

clients = []

async def handle_client(reader, writer):
addr, port = writer.get_extra_info('peername')
print(f"New connection from {addr}:{port}")

clients.append(writer)

try:
	while True:
		data = await reader.read(100) # 100 bytes at a time
		if not data:
			break
		# make sure all data is received from client

		for client in clients:
			if client != writer:
				client.write(message)
				await client.drain()
		# send message to the rest of the clients connected to the chat server
except asyncio.CancelledError:
	pass
finally:
	print(f"Closing connection with {addr}:{port}")
	clients.remove(writer)
	write.close()
	await writer.wait_closed()

async def main():
	central_server = await asyncio.start_server(handle_client, '127.0.0.1', 48484)
	addr, port = central_server.sockets[0].getsockname()
	print(f'serving on {addr}:{port}')

	async with central_server:
		await central_server.serve_forever()

asyncio.run(main())