def handle_update_machine_auth(self, msg): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientUpdateMachineAuth) message.parse(msg) sentryfile = message.body.bytes hash = Util.sha1_hash(sentryfile) self.callback.store_sentry_file(self.username, sentryfile) response = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientUpdateMachineAuthResponse, EMsg.ClientUpdateMachineAuthResponse) response.header.target_jobid = message.header.source_jobid response.body.cubwrote = message.body.cubtowrite response.body.eresult = EResult.OK response.body.filename = message.body.filename response.body.filesize = message.body.cubtowrite response.body.getlasterror = 0 response.body.offset = message.body.offset response.body.sha_file = hash response.body.otp_identifier = message.body.otp_identifier response.body.otp_type = message.body.otp_type self.connection.send_message(response)
def requestEconData(self, param_a, param_d, param_s=0, param_m=0): message = msg_base.ProtobufMessage( cstrike15_gcmessages_pb2. CMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockRequest, csgo_base.ECSGOCMsg. k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockRequest) message.body.param_s = param_s # SteamID message.body.param_a = param_a # AssetID message.body.param_d = param_d message.body.param_m = param_m # MarketID self.gc.gcSend(message) response = self.gc.client.wait_for_message(EMsg.ClientFromGC, timeout=5.0) if response == 'Timed Out': return 'Steam servers did not respond, your time delay is probably too small.' elif Util.get_msg( response.body.msgtype ) == csgo_base.ECSGOCMsg.k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockResponse: econData = self.gc.gcFrom( response.body.payload, cstrike15_gcmessages_pb2. CMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockResponse) return econData else: return 'Response was not of type EconPreviewDataBlockResponse'
def _heartbeat(self, time): while self.socket: sleep(time) message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientHeartBeat, EMsg.ClientHeartBeat) self.send_message(message)
def launch(self): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientGamesPlayed, EMsg.ClientGamesPlayed) message.body.games_played.add(game_id=self.appid) self.gc.client.connection.send_message(message) time.sleep(3) try: response = self.sendClientHello() if Util.get_msg( response.body.msgtype ) == csgo_base.EGCBaseClientMsg.k_EMsgGCClientWelcome: logEvent('Launch successful!') return True else: logEvent('Tried to launch, but got ' + str(Util.get_msg(response.body.msgtype))) return False except Exception: logEvent( 'Not connected, client hello failed to respond. (This is normal on first attempt)' ) return False
def sendClientHello(self): message = msg_base.ProtobufMessage( gcsdk_gcmessages_pb2.CMsgClientHello, csgo_base.EGCBaseClientMsg.k_EMsgGCClientHello) self.gc.gcSend(message) response = self.gc.client.wait_for_message(EMsg.ClientFromGC) return response
def handle_client_logon(self, msg): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientLogonResponse) message.parse(msg) if message.body.steam2_ticket: self.steam2_ticket = message.body.steam2_ticket self.logon_event.set()
def logon_response(self, msg): message = msg_base.ProtobufMessage(steammessages_clientserver_pb2.CMsgClientLogonResponse) message.parse(msg) if message.body.eresult == EResult.OK: self.session_id = message.proto_header.client_sessionid self.steamid = SteamID(message.proto_header.steamid) delay = message.body.out_of_game_heartbeat_seconds self.heartbeat = gevent.spawn(self._heartbeat, delay)
def get_depot_key(self, depot_id, app_id=0): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientGetDepotDecryptionKey, EMsg.ClientGetDepotDecryptionKey) message.body.depot_id = depot_id message.body.app_id = app_id response = self.client.wait_for_job( message, EMsg.ClientGetDepotDecryptionKeyResponse) return response.body
def handle_server_list(self, msg): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientServerList) message.parse(msg) for server in message.body.servers: if not server.server_type in self.server_list: self.server_list[server.server_type] = [] self.server_list[server.server_type].append( (Util.long2ip(server.server_ip), server.server_port))
def login(self, username=None, password=None, login_key=None, auth_code=None, steamid=0, two_factor_code=None): self.username = username message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientLogon, EMsg.ClientLogon) message.proto_header.client_sessionid = 0 if steamid > 0: message.proto_header.steamid = steamid else: message.proto_header.steamid = SteamID.make_from( 0, 0, EUniverse.Public, EAccountType.Individual).steamid message.body.protocol_version = 65575 message.body.client_package_version = 1771 message.body.client_os_type = 10 message.body.client_language = "english" message.body.machine_id = "OK" message.body.account_name = username message.body.password = password if login_key: message.body.login_key = login_key if auth_code: message.body.auth_code = auth_code if two_factor_code: message.body.two_factor_code = two_factor_code sentryfile = self.callback.get_sentry_file(username) if sentryfile: message.body.sha_sentryfile = Util.sha1_hash(sentryfile) message.body.eresult_sentryfile = EResult.OK else: message.body.eresult_sentryfile = EResult.FileNotFound localip = self.connection.get_bound_address() message.body.obfustucated_private_ip = 1111 self.connection.send_message(message) logonResponse = self.wait_for_message(EMsg.ClientLogOnResponse) if self.steamid: self.account_type = self.steamid.accounttype return logonResponse.body
def get_changes_since(self, last_change_number, send_app_changes=True, send_package_changes=False): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgPICSChangesSinceRequest, EMsg.PICSChangesSinceRequest) message.body.since_change_number = last_change_number message.body.send_app_info_changes = send_app_changes message.body.send_package_info_changes = send_package_changes response = self.client.wait_for_job(message, EMsg.PICSChangesSinceResponse) return response.body
def get_access_tokens(self, apps=None, packages=None): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgPICSAccessTokenRequest, EMsg.PICSAccessTokenRequest) if apps: message.body.appids.extend(apps) if packages: message.body.packageids.extend(packages) response = self.client.wait_for_job(message, EMsg.PICSAccessTokenResponse) return response.body
def gcSend(self, inputmsg): Type = inputmsg.header.emsg if logging == 2: logEvent('gcSend ' + str(Util.get_msg(Type))) message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgGCClient, EMsg.ClientToGC) message.header.routing_appid = self.appid message.body.appid = self.appid message.body.msgtype = Type | 0x80000000 if Util.is_proto( Type) else Type message.body.payload = inputmsg.serialize() self.client.connection.send_message(message)
def login_anonymous(self): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientLogon, EMsg.ClientLogon) message.proto_header.client_sessionid = 0 message.proto_header.steamid = SteamID.make_from( 0, 0, EUniverse.Public, EAccountType.AnonUser).steamid message.body.protocol_version = 65575 message.body.client_os_type = 10 message.body.machine_id = "OK" self.connection.send_message(message) logonResponse = self.wait_for_message(EMsg.ClientLogOnResponse) return logonResponse.body
def split_multi_message(self, msg): message = msg_base.ProtobufMessage(steammessages_base_pb2.CMsgMulti) message.parse(msg) payload = message.body.message_body if message.body.size_unzipped > 0: zip_buffer = StringIO.StringIO(message.body.message_body) with zipfile.ZipFile(zip_buffer, 'r') as zip: payload = zip.read('z') i = 0 while i < len(payload): sub_size, = struct.unpack_from('<I', payload, i) self.dispatch_message(payload[i+4:i+4+sub_size]) i += sub_size + 4
def get_cdn_auth_token(self, appid, host): if self.cdn_token_cache.get((appid, host)): return self.cdn_token_cache[(appid, host)] message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientGetCDNAuthToken, EMsg.ClientGetCDNAuthToken) message.body.app_id = appid message.body.host_name = host response = self.client.wait_for_job(message, EMsg.ClientGetCDNAuthTokenResponse) self.cdn_token_cache[(appid, host)] = response.body return response.body
def get_app_ticket(self, appid): if self.client.account_type != EAccountType.Individual: return None if self.ticket_cache.get(appid): return self.ticket_cache[appid] message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientGetAppOwnershipTicket, EMsg.ClientGetAppOwnershipTicket) message.body.app_id = appid response = self.client.wait_for_job( message, EMsg.ClientGetAppOwnershipTicketResponse) self.ticket_cache[appid] = response.body return response.body
def get_product_info(self, apps=None, packages=None): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgPICSProductInfoRequest, EMsg.PICSProductInfoRequest) if apps: for app in apps: app_info = message.body.apps.add() app_info.only_public = False if isinstance(app, tuple): app_info.appid, app_info.access_token = app else: app_info.appid = app if packages: for package in packages: package_info = message.body.packages.add() if isinstance(package, tuple): package_info.appid, package_info.access_token = package else: package_info.packageid = package message.body.meta_data_only = False response = self.client.wait_for_job(message, EMsg.PICSProductInfoResponse) for app in response.body.apps: self.app_cache[app.appid] = vdf.loads(app.buffer)['appinfo'] for package in response.body.packages: kv = vdf.loadbinary(package.buffer[4:]) self.package_cache[package.packageid] = kv[0][str( package.packageid)] return response.body
def exit(self): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientGamesPlayed, EMsg.ClientGamesPlayed) self.gc.client.connection.send_message(message)
def logout(self): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientLogOff, EMsg.ClientLogOff) self.connection.send_message(message) return None
def handle_session_token(self, msg): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientSessionToken) message.parse(msg) self.session_token = message.body.token
def gcFrom(self, data, protobufType): if logging == 2: logEvent('gcFrom ' + str(protobufType)) message = msg_base.ProtobufMessage(protobufType) message.parse(data) return message.body
def handle_license_list(self, msg): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientLicenseList) message.parse(msg) self.licenses = message.body.licenses
def setState(self, state): message = msg_base.ProtobufMessage( steammessages_clientserver_pb2.CMsgClientChangeStatus, EMsg.ClientChangeStatus) message.body.persona_state = state self.client.connection.send_message(message)