Reverse proxy to multiple minecraft servers based on domain

[tW4r]

This project already does proxying
internet:25565 -> lazymc:25565 -> minecraft server:25566

It is possible to determine the domain the user is connecting to from the login packet
Based on this fact it is possible to direct them to different minecraft servers as such

server-a.example.com:25565 \                  / minecraft server-a:25566
                           +-> lazymc:25565 ->+
server-b.example.com:25565 /                  \ minecraft server-b:25567

An example of this is infrared (https://github.com/haveachin/infrared)

I would imagine it could work by splitting lazymc.toml to multiple files in a config directory:

# file 1
[public]
address="server-a.example.com"
[server]
address="127.0.0.1:22566"

# file 2
[public]
address="server-b.example.com"
[server]
address="127.0.0.1:22567"

[timvisee]

I believe this is definitely possible.

The target address or hostname is part of the handshake packet, sent from the client to the server: https://wiki.vg/Protocol#Serverbound

This can probably be implemented by:

• grab the target address or hostname from the handshake packet
• set-up connection to target server
• replay handshake to target server
• proxy client connection to target server

I must admit that is has been a while since I dove into the Minecraft protocol, but I'm quite sure it can be done this way without hijacking authentication or something like that.

This must probably be implemented here:

lazymc/src/status.rs

Lines 67 to 102 in 2c00dba

	// Hijack handshake
	if client_state == ClientState::Handshake
	&& packet.id == packets::handshake::SERVER_HANDSHAKE
	{
	// Parse handshake
	let handshake = match Handshake::decode(&mut packet.data.as_slice()) {
	Ok(handshake) => handshake,
	Err(_) => {
	debug!(target: "lazymc", "Got malformed handshake from client, disconnecting");
	break;
	}
	};
	// Parse new state
	let new_state = match ClientState::from_id(handshake.next_state) {
	Some(state) => state,
	None => {
	error!(target: "lazymc", "Client tried to switch into unknown protcol state ({}), disconnecting", handshake.next_state);
	break;
	}
	};
	// Update client info and client state
	client_info
	.protocol
	.replace(handshake.protocol_version as u32);
	client_info.handshake.replace(handshake);
	client.set_state(new_state);
	// If loggin in with handshake, remember inbound
	if new_state == ClientState::Login {
	inbound_history.extend(raw);
	}
	continue;
	}