def __init__(self,
minecraft_version=None,
compression_threshold=None,
client_handler_type=FakeClientHandler,
private_key=None,
public_key_bytes=None,
test_case=None):
if minecraft_version is None:
minecraft_version = list(SUPPORTED_MINECRAFT_VERSIONS.keys())[-1]
if isinstance(minecraft_version, Integral):
proto = minecraft_version
minecraft_version = 'FakeVersion%d' % proto
for ver, ver_proto in SUPPORTED_MINECRAFT_VERSIONS.items():
if ver_proto == proto:
minecraft_version = ver
else:
proto = SUPPORTED_MINECRAFT_VERSIONS[minecraft_version]
self.context = connection.ConnectionContext(protocol_version=proto)
self.minecraft_version = minecraft_version
self.compression_threshold = compression_threshold
self.client_handler_type = client_handler_type
self.private_key = private_key
self.public_key_bytes = public_key_bytes
self.test_case = test_case
self.packets_handshake = {
p.get_id(self.context): p
for p in serverbound.handshake.get_packets(self.context)
}
self.packets_login = {
p.get_id(self.context): p
for p in serverbound.login.get_packets(self.context)
}
self.packets_playing = {
p.get_id(self.context): p
for p in serverbound.play.get_packets(self.context)
}
self.packets_status = {
p.get_id(self.context): p
for p in serverbound.status.get_packets(self.context)
}
self.listen_socket = socket.socket()
self.listen_socket.settimeout(0.1)
self.listen_socket.bind(('localhost', 0))
self.listen_socket.listen(1)
self.lock = threading.Lock()
self.stopping = False
super(FakeServer, self).__init__()
class AllowedVersionsTest(fake_server._FakeServerTest):
versions = sorted(SUPPORTED_MINECRAFT_VERSIONS.items(), key=lambda p: p[1])
versions = dict((versions[0], versions[len(versions) // 2], versions[-1]))
client_handler_type = ConnectTest.client_handler_type
def test_with_version_names(self):
for version, proto in AllowedVersionsTest.versions.items():
client_versions = {
v
for (v, p) in SUPPORTED_MINECRAFT_VERSIONS.items()
if p <= proto
}
self._test_connect(server_version=version,
client_versions=client_versions)
def test_with_protocol_numbers(self):
for version, proto in AllowedVersionsTest.versions.items():
client_versions = {
p
for (v, p) in SUPPORTED_MINECRAFT_VERSIONS.items()
if p <= proto
}
self._test_connect(server_version=version,
client_versions=client_versions)
def test_with_protocol_numbers(self):
for version, proto in AllowedVersionsTest.versions.items():
client_versions = {
p for (v, p) in SUPPORTED_MINECRAFT_VERSIONS.items()
if p <= proto}
self._test_connect(
server_version=version, client_versions=client_versions)
def test_with_protocol_numbers(self):
for version, proto in AllowedVersionsTest.versions.items():
client_versions = {
p for (v, p) in SUPPORTED_MINECRAFT_VERSIONS.items()
if p <= proto}
self._test_connect(
server_version=version, client_versions=client_versions)
def __init__(self, minecraft_version=None):
if minecraft_version is None:
minecraft_version = SUPPORTED_MINECRAFT_VERSIONS.keys()[-1]
self.minecraft_version = minecraft_version
protocol_version = SUPPORTED_MINECRAFT_VERSIONS[minecraft_version]
self.context = connection.ConnectionContext(
protocol_version=protocol_version)
self.packets_handshake = {
p.get_id(self.context): p
for p in packets.state_handshake_serverbound(self.context)
}
self.packets_login = {
p.get_id(self.context): p
for p in packets.state_login_serverbound(self.context)
}
self.packets_playing = {
p.get_id(self.context): p
for p in packets.state_playing_serverbound(self.context)
}
self.listen_socket = socket.socket()
self.listen_socket.bind(('0.0.0.0', 0))
self.listen_socket.listen(0)
super(FakeServer, self).__init__()
def __init__(self, minecraft_version=None, compression_threshold=None,
client_handler_type=FakeClientHandler, private_key=None,
public_key_bytes=None, test_case=None):
if minecraft_version is None:
minecraft_version = VERSIONS[-1][0]
if isinstance(minecraft_version, Integral):
proto = minecraft_version
minecraft_version = 'FakeVersion%d' % proto
for ver, ver_proto in SUPPORTED_MINECRAFT_VERSIONS.items():
if ver_proto == proto:
minecraft_version = ver
else:
proto = SUPPORTED_MINECRAFT_VERSIONS[minecraft_version]
self.context = connection.ConnectionContext(protocol_version=proto)
self.minecraft_version = minecraft_version
self.compression_threshold = compression_threshold
self.client_handler_type = client_handler_type
self.private_key = private_key
self.public_key_bytes = public_key_bytes
self.test_case = test_case
self.packets_handshake = {
p.get_id(self.context): p for p in
serverbound.handshake.get_packets(self.context)}
self.packets_login = {
p.get_id(self.context): p for p in
serverbound.login.get_packets(self.context)}
self.packets_playing = {
p.get_id(self.context): p for p in
serverbound.play.get_packets(self.context)}
self.packets_status = {
p.get_id(self.context): p for p in
serverbound.status.get_packets(self.context)}
self.listen_socket = socket.socket()
self.listen_socket.settimeout(0.1)
self.listen_socket.bind(('localhost', 0))
self.listen_socket.listen(0)
self.lock = threading.Lock()
self.stopping = False
super(FakeServer, self).__init__()
class AllowedVersionsTest(fake_server._FakeServerTest):
versions = list(SUPPORTED_MINECRAFT_VERSIONS.items())
test_indices = (0, len(versions) // 2, len(versions) - 1)
client_handler_type = ConnectTest.client_handler_type
def test_with_version_names(self):
for index in self.test_indices:
self._test_connect(
server_version=self.versions[index][0],
client_versions={v[0] for v in self.versions[:index+1]})
def test_with_protocol_numbers(self):
for index in self.test_indices:
self._test_connect(
server_version=self.versions[index][0],
client_versions={v[1] for v in self.versions[:index+1]})
from cryptography.hazmat.primitives.asymmetric.padding import PKCS1v15
from numbers import Integral
import unittest
import threading
import logging
import socket
import json
import sys
import zlib
import hashlib
import uuid
VERSIONS = sorted(SUPPORTED_MINECRAFT_VERSIONS.items(), key=lambda i: i[1])
VERSIONS = [v for (v, p) in VERSIONS]
THREAD_TIMEOUT_S = 2
class FakeClientDisconnect(Exception):
""" Raised by 'FakeClientHandler.read_packet' if the client has cleanly
disconnected prior to the call.
"""
class FakeServerDisconnect(Exception):
""" May be raised within 'FakeClientHandler.handle_*' in order to terminate
the client's connection. 'message' is provided as an argument to
'handle_play_server_disconnect' or 'handle_login_server_disconnect'.
from minecraft import SUPPORTED_MINECRAFT_VERSIONS
from minecraft.networking import connection
from minecraft.networking import types
from minecraft.networking import packets
from future.utils import raise_
import unittest
import threading
import logging
import socket
import json
import sys
VERSIONS = sorted(SUPPORTED_MINECRAFT_VERSIONS.items(), key=lambda i: i[1])
THREAD_TIMEOUT_S = 5
class _ConnectTest(unittest.TestCase):
def _test_connect(self, client_version=None, server_version=None):
server = FakeServer(minecraft_version=server_version)
addr, port = server.listen_socket.getsockname()
cond = threading.Condition()
def handle_client_exception(exc, exc_info):
with cond:
cond.exc_info = exc_info
cond.notify_all()
def main() -> int:
# Handle program arguments
ap = argparse.ArgumentParser(
prog="mchat",
description="A console chat client for most Minecraft server versions")
ap.add_argument("server_address", help="IP address of a Minecraft server")
ap.add_argument("-p",
"--port",
help="Minecraft server port (default: %(default)s)",
type=int,
default=25565)
ap.add_argument("-u", "--username", help="Minecraft username or email")
ap.add_argument(
"-v",
"--version",
help="Client -> Server protocol version to use (default: %(default)s)",
default="1.16.4")
args = ap.parse_args()
# Verify server version to keep the terminal looking clean
if args.version not in SUPPORTED_MINECRAFT_VERSIONS.keys():
console.print(
f"[bold yellow]{args.version} is not a valid Minecraft version. Versions from {list(SUPPORTED_MINECRAFT_VERSIONS.keys())[0]} to {list(SUPPORTED_MINECRAFT_VERSIONS.keys())[-1]} are allowed."
)
return 1
# Do authentication
if not args.username:
username = Prompt.ask("Username or email")
else:
username = args.username
password = getpass.getpass("Password: "******"[bright_black]Loaded authentication information")
# Determine the actual protocol version number
protocol_version_num = SUPPORTED_MINECRAFT_VERSIONS[args.version]
console.print(
f"[bright_black]Selecting protocol version {protocol_version_num}")
# Authenticate with Mojang
auth_token = AuthenticationToken()
console.print(f"[bright_black]Contacting Yggdrasil...")
try:
auth_token.authenticate(username, password)
except YggdrasilError as e:
console.print(f"[bold red]Failed to authenticate Minecraft session")
return 1
# Open a connection
server_connection = Connection(args.server_address,
args.port,
auth_token,
allowed_versions=[protocol_version_num])
try:
server_connection.connect()
except:
console.print(f"[bold red]Could not connect to server")
return 1
# Set up an incoming chat handler
server_connection.register_packet_listener(incomingChatHandler,
ChatMessagePacket)
console.print(f"[bright_black]Listen to incoming chat packets")
# Set up input loop
console.print(
"All further inputs will be sent to server chat. Press CTRL+C to stop")
try:
while True:
# Get a line from the user
chat_message = console.input()
# Send the chat message
packet = serverbound.play.ChatPacket()
packet.message = chat_message
server_connection.write_packet(packet)
except KeyboardInterrupt as e:
print("\rGoodbye")
return 0
