def ToClient(self, client, packet):
#Stage 5: Enable encryption and send Client Status
client.enable_crypto(client.SharedSecret)
client.push(mcpacket.Packet(ident = 0xCD, data = {
'payload': 0,
})
)
def read_packet(self, data=b''):
self.rbuff.append(
self.cipher.decrypt(data) if self.encrypted else data)
while True:
self.rbuff.save()
try:
packet = mcpacket.Packet(ident=(
self.proto_state,
mcdata.SERVER_TO_CLIENT,
)).decode(self.rbuff, self.comp_state)
except utils.BufferUnderflowException:
self.rbuff.revert()
break
except mcpacket.PacketDecodeFailure as err:
logger.warning('Packet decode failed')
logger.warning('Failed packet ident is probably: %s',
err.packet.str_ident)
self.event.emit('PACKET_ERR', err)
break
#print '[net.py]read packet.ident %s'%(str(packet.ident))
#print '[net.py]read packet.str_ident %s'%(packet.str_ident)
rostime = rospy.Time.now()
packet.data['ROStimestamp'] = rostime.secs * 10e9 + rostime.nsecs
packet.data['MCtimestamp'] = self.timer.world.time_of_day
self.event.emit(packet.ident, packet)
self.event.emit(packet.str_ident, packet)
def reconnect(self):
self.net.connect(self.host, self.port)
self.net.push(
mcpacket.Packet(ident=(mcdata.HANDSHAKE_STATE,
mcdata.CLIENT_TO_SERVER, 0x00),
data={
'protocol_version': mcdata.MC_PROTOCOL_VERSION,
'host': self.net.host,
'port': self.net.port,
'next_state': mcdata.LOGIN_STATE
}))
self.net.push(
mcpacket.Packet(
ident=(mcdata.LOGIN_STATE, mcdata.CLIENT_TO_SERVER, 0x00),
data={'name': self.auth.username},
))
def handshake(self):
self.net.push(
mcpacket.Packet(ident='HANDSHAKE>Handshake',
data={
'protocol_version': mcdata.MC_PROTOCOL_VERSION,
'host': self.net.host,
'port': self.net.port,
'next_state': mcdata.LOGIN_STATE
}))
def handle_update_health(self, name, packet):
#You be dead
if packet.data['health'] <= 0.0:
self.net.push(mcpacket.Packet(
ident = (mcdata.PLAY_STATE, mcdata.CLIENT_TO_SERVER, 0x16),
data = {
'action': mcdata.CL_STATUS_RESPAWN,
}
))
def handshake(self):
self.net.push(
mcpacket.Packet(ident=(mcdata.HANDSHAKE_STATE,
mcdata.CLIENT_TO_SERVER, 0x00),
data={
'protocol_version': mcdata.MC_PROTOCOL_VERSION,
'host': self.net.host,
'port': self.net.port,
'next_state': mcdata.LOGIN_STATE
}))
def login(self, host='localhost', port=25565):
self.connect(host, port)
self.SharedSecret = Random._UserFriendlyRNG.get_random_bytes(16)
#Stage 2: Send initial handshake
self.push(
mcpacket.Packet(ident=02,
data={
'protocol_version': mcdata.MC_PROTOCOL_VERSION,
'username': self.username,
'host': host,
'port': port,
}))
def send_update(self, position=None):
if not self.alive:
return
self.move_around()
if position is None:
position = self.client_info.position
self.net.push(
mcpacket.Packet(ident='PLAY>Player Position and Look',
data=position,
silent=True))
def handle_respawn(self, name, packet):
self.net.push(
mcpacket.Packet(
ident=(mcdata.PLAY_STATE, mcdata.CLIENT_TO_SERVER, 0x06),
#TODO: check flags to see if Absolute vs Relative
data={
'x': self.clientinfo.position['x'],
'y': self.clientinfo.position['y'],
'z': self.clientinfo.position['z'],
'pitch': self.clientinfo.position['pitch'],
'yaw': self.clientinfo.position['yaw'],
'on_ground': False
}))
def client_tick(self, name, data):
self.net.push(
mcpacket.Packet(
ident=(mcdata.PLAY_STATE, mcdata.CLIENT_TO_SERVER, 0x06),
#TODO: check flags to see if Absolute vs Relative
data={
'x': self.clientinfo.position['x'],
'y': self.clientinfo.position['y'],
'z': self.clientinfo.position['z'],
'stance': self.clientinfo.position['stance'],
'pitch': self.clientinfo.position['pitch'],
'yaw': self.clientinfo.position['yaw'],
'on_ground': True
}))
def read_packet(self, data = b''): self.rbuff.append(self.cipher.decrypt(data) if self.encrypted else data) while True: self.rbuff.save() try: packet = mcpacket.Packet(ident = ( self.proto_state, mcdata.SERVER_TO_CLIENT, )).decode(self.rbuff, self.comp_state) except utils.BufferUnderflowException: self.rbuff.revert() break if packet: self.event.emit(packet.ident, packet) self.event.emit(packet.str_ident, packet)
def exit(self):
self.push(
mcpacket.Packet(ident=0xFF, data={'reason':
'KILL_EVENT recieved'}))
while self.sbuff:
self.getflags()
if self.flags & (cflags['SOCKET_ERR'] | cflags['SOCKET_HUP']):
break
elif self.flags & cflags['SOCKET_SEND']:
fhandles[cflags['SOCKET_SEND']](self)
self.sock.close()
if self.pidfile and os.path.exists(self.pidfile):
os.remove(self.pidfile)
sys.exit(0)
def ToClient(self, client, packet):
#Stage 3: Authenticate with session.minecraft.net
pubkey = packet.data['public_key']
if client.authenticated:
serverid = utils.HashServerId(packet.data['server_id'], client.SharedSecret, pubkey)
SessionResponse = utils.AuthenticateMinecraftSession(client.username, client.sessionid, serverid)
if (SessionResponse != 'OK'):
logging.error('Session Authentication Failed, Response: %s', SessionResponse)
client.auth_err = True
return
#Stage 4: Send an Encryption Response
RSACipher = PKCS1_v1_5.new(RSA.importKey(pubkey))
encryptedSanityToken = RSACipher.encrypt(str(packet.data['verify_token']))
encryptedSharedSecret = RSACipher.encrypt(str(client.SharedSecret))
client.push(mcpacket.Packet(ident = 0xFC, data = {
'shared_secret': encryptedSharedSecret,
'verify_token': encryptedSanityToken,
})
)
def handle01(self, name, packet):
pubkey = packet.data['public_key']
if self.authenticated:
serverid = JavaHexDigest(
hashlib.sha1(packet.data['server_id'].encode('ascii') +
self.auth.shared_secret + pubkey))
print(
'Attempting to authenticate session with sessionserver.mojang.com'
)
url = "https://sessionserver.mojang.com/session/minecraft/join"
data = json.dumps({
'accessToken': self.auth.ygg.access_token,
'selectedProfile': self.auth.selected_profile,
'serverId': serverid,
}).encode('utf-8')
headers = {'Content-Type': 'application/json'}
req = request.Request(url, data, headers, method='POST')
try:
rep = request.urlopen(req).read().decode('ascii')
except URLError:
rep = 'Couldn\'t connect to sessionserver.mojang.com'
#if rep != 'OK':
# print('Session Authentication Failed, Response:', rep)
# self.event.emit('SESS_ERR')
# return
print(rep)
rsa_cipher = PKCS1_v1_5.new(RSA.importKey(pubkey))
self.net.push(
mcpacket.Packet(
ident=(mcdata.LOGIN_STATE, mcdata.CLIENT_TO_SERVER, 0x01),
data={
'shared_secret':
rsa_cipher.encrypt(self.auth.shared_secret),
'verify_token':
rsa_cipher.encrypt(packet.data['verify_token']),
}))
self.net.enable_crypto(self.auth.shared_secret)
def login_start(self):
self.net.push(
mcpacket.Packet(
ident='LOGIN>Login Start',
data={'name': self.auth.username},
))
def ToClient(self, client, packet): for key, value in packet.data.iteritems(): client.position[key] = value client.push(mcpacket.Packet(ident=0x0D, data = client.position))
def login_start(self):
self.net.push(
mcpacket.Packet(
ident=(mcdata.LOGIN_STATE, mcdata.CLIENT_TO_SERVER, 0x00),
data={'name': self.auth.username},
))
def push_packet(self, ident, data):
self.push(mcpacket.Packet(ident, data))
