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