def setup(): client = SteamClient() try: client.login(username=config.STEAM_USERNAME, password=config.STEAM_PASS) except: error_message = traceback.format_exc() now = str(datetime.now()) print(f'{now} - Error:\n{error_message}\n\n\n') time.sleep(60) setup() check_for_updates(client)
def setup(): client = SteamClient() try: client.login(username='', password='', auth_code='') except: error_message = traceback.format_exc() now = str(datetime.now()) print(now + ' - Error:\n' + error_message + '\n\n\n') time.sleep(60) setup() checkForUpdates(client)
def steam_login(username, password, two_factor_code): """Logs in to steam, returns logged in client if successful, raises SteamLoginException if not :param username: username of account :type username :class:`str` :param password: password of account :type password :class:`str` :param two_factor_code: valid 2FA code :type two_factor_code :class:`str` :return steam_client of logged in user :rtype `SteamClient` :raises `SteamLoginException` """ steam_client = SteamClient() # Make steam client object steam_client.login(username, password, two_factor_code=two_factor_code) # Log in if not steam_client.logged_on: # Login failed raise SteamLoginException('Login failed.') return steam_client
cs.launch() @cs.on('ready') def gc_ready(): print('Ready') for code in codes: meme = csgo.sharecode.decode(code) print(meme) cs.request_full_match_info(meme['matchid'], meme['outcomeid'], meme['token']) response, = cs.wait_event('full_match_info') site = response.matches[0].roundstatsall[-1].map file_name = f"./unprocessed/{meme['matchid']}_{meme['outcomeid']}_{meme['token']}" print(site) print(file_name) req = urllib.request.Request(site, headers=hdr) try: with urllib.request.urlopen(req) as res, open(file_name, 'wb') as out_file: shutil.copyfileobj(res, out_file) except urllib.error.HTTPError as e: print(e) cs.exit() cs.emit('meme') client.login(username=auth['usr'], password=auth['pass']) cs.wait_event('meme')
} client = SteamClient() @client.on('error') def error(result): print("Logon result:", repr(result)) @client.on('auth_code_required') def auth_code_prompt(is_2fa, mismatch): if is_2fa: code = input("Enter 2FA Code: ") client.login(two_factor_code=code, **LOGON_DETAILS) else: code = input("Enter Email Code: ") client.login(auth_code=code, **LOGON_DETAILS) try: client.login(**LOGON_DETAILS) except: raise SystemExit print("-"*20) print("Logged on as:", client.user.name) print("Community profile:", client.steam_id.community_url) print("Last logon:", client.user.last_logon) print("Last logoff:", client.user.last_logoff) client.logout()
print("\nReconnecting...") client.reconnect(maxdelay=30) @client.friends.on("friend_invite") def accept_invite(user): client.friends.add(user) if user.name == None: print("\nAdded:", user.steam_id) else: print("\nAdded:", user.name) gevent.sleep(2) user.send_message(config[9]) try: result = client.login(username=config[1], password=config[3], two_factor_code=SA.get_code()) if result != EResult.OK: print("Failed to login:"******"Logout") client.logout() raise SystemExit
def run_account(acc): client = SteamClient() client.set_credential_location('creds') cs = CSGOClient(client) profile = gevent.event.Event() matches = gevent.event.Event() events.append(profile) events.append(matches) @client.on('logged_on') def start_csgo(): print("Logged in!") cs.launch() print("Launched CS:GO") @client.on('new_login_key') def key(): print(f"New login key for {acc['username']}!") acc['login_key'] = client.login_key #@client.on(None) #def kek(msgtype, msg=None): # print(msgtype) # print(msg) @client.on(EMsg.ClientVACBanStatus) def vac_status(msg): acc['bans'] = msg.body.numBans @client.on(EMsg.ClientEmailAddrInfo) def email(msg): acc['email'] = msg.body.email_address @client.on(EMsg.ClientAccountInfo) def name(msg): acc['name'] = msg.body.persona_name @client.on(EMsg.ClientWalletInfoUpdate) def name(msg): if msg.body.currency: acc['wallet_balance'] = msg.body.balance64 acc['wallet_balance_delayed'] = msg.body.balance64_delayed acc['wallet_currency'] = msg.body.currency @cs.on('ready') def gc_ready(): print("CS:GO Ready!") cs.request_player_profile(cs.account_id) cs.request_recent_user_games(cs.account_id) print("Requested player profile info") @cs.on('recent_user_games') def got_matches(resp): if len(resp.matches) > 0: acc['last_mm'] = resp.matches[-1].matchtime matches.set() @cs.on('player_profile') def got_profile(response): if response.account_id == cs.account_id: print(f"Got {acc['username']} CS:GO profile!") acc['csgo_profile'] = json.loads(json_format.MessageToJson(response)) #cs.exit() #client.logout() profile.set() # def cleanup(): print(f'Logging in to {acc["username"]}') if 'login_key' not in acc or client.login(acc['username'], login_key=acc['login_key']) != 1: client.cli_login(acc['username'], acc['password'])
@client.on(EMsg.ServiceMethod) def handle_games_played(msg): if hasattr(msg.body, 'games'): print(f'Now playing {msg.body.games[0].appid}') @client.on(EMsg.ClientPersonaState) def handle_persona_state(msg): for f in msg.body.friends: if f.friendid == sl.friend and not f.gameid: print(f'{f.player_name} no longer in game') sl.clear() client.games_played(app_ids) break try: two_factor_code = generate_twofactor_code(base64.b64decode(SHARED_SECRET)) result = client.login(USERNAME, PASSWORD, None, None, two_factor_code) if result != EResult.OK: print(f'Failed to login: {repr(result)}') raise SystemExit client.run_forever() except KeyboardInterrupt: if client.connected: print("Logout") client.logout()
def start_bot(self, credentials): client = SteamClient() dota = Dota2Client(client) self.bots.append(dota) client.verbose_debug = True dota.verbose_debug = True @client.on('logged_on') def start_dota(): dota.launch() # TODO: don't try to relogin if we disconnected by KeyboardInterrupt @client.on('disconnected') def handle_disconnect(): print('Disconnected: %s' % credentials['login']) delay = 30 print('Trying to login again in %d sec...' % delay) gevent.sleep(delay) client.login(credentials['login'], credentials['password']) client.run_forever() @dota.on('ready') def dota_started(): print('Logged in: %s %s' % (dota.steam.username, dota.account_id)) # register this bot as a player in db player, created = Player.objects.get_or_create( dota_id=dota.account_id, defaults={ 'name': dota.steam.username, 'dota_mmr': random.randrange(3000, 6000, 500) }) print('Bot %s (%d MMR, %s), was already in DB: %s' % (player.name, player.dota_mmr, player.dota_id, not created)) # if lobby is hung up from previous session, leave it dota.leave_practice_lobby() dota.join_practice_lobby(self.lobby, self.password) @dota.on(dota2.features.Lobby.EVENT_LOBBY_NEW) def lobby_new(lobby): print('%s joined lobby %s' % (dota.steam.username, lobby.lobby_id)) ind = self.bots.index(dota) if ind == 0: # let first bot listen to lobby chat dota.channels.join_lobby_channel() team = ind // 5 slot = ind % 5 + 1 dota.join_practice_lobby_team(slot, team) @dota.on(dota2.features.Lobby.EVENT_LOBBY_CHANGED) def lobby_changed(lobby): if dota != self.bots[0]: return players = [ player for player in lobby.members if player.team in (DOTA_GC_TEAM.GOOD_GUYS, DOTA_GC_TEAM.BAD_GUYS) ] if len(players) == 0 and self.balance_team1: print() print('All bots jumped to unassigned') self.join_balance_slots() @dota.channels.on(dota2.features.chat.ChannelManager.EVENT_MESSAGE) def chat_message(channel, msg_obj): text = msg_obj.text if channel.type != DOTAChatChannelType_t.DOTAChannelType_Lobby: return # ignore postgame and other chats # process known commands if text.startswith('Team 1'): self.balance_ready(text) client.login(credentials['login'], credentials['password']) client.run_forever()
class AuthAccount: def __init__(self): self.client = SteamClient() # self.client.set_credential_location(rf"{os.path.abspath(os.curdir)}/lib/data/") self.accounts = Accounts() self.code = False self.code_needed = "" def login(self, username, password, two_factor_code=None, email_code=None): account_in_base = self.accounts.check_account(username) if two_factor_code is not None: resp = self.client.login(username=username, password=password, two_factor_code=two_factor_code) response = self.check_login_response(resp, username, password, account_in_base) print(f"Two factor code is not none: {response}, {resp}") if response == "2FA Mismatch": return "2FA Mismatch" elif response == "Successfully logged in": return "Successfully logged in" elif email_code is not None: resp = self.client.login(username=username, password=password, auth_code=email_code) response = self.check_login_response(resp, username, password, account_in_base) print(f"Email code is not none: {response}, {resp}") if response == "Need Email Code": return "Account logon denied" elif response == "Successfully logged in": return "Successfully logged in" else: pass if account_in_base == "OK": try: login_key = self.accounts.get_login_key(username) resp = self.client.login(username=username, login_key=login_key) print(resp) response = self.check_login_response(resp, username, password, account_in_base) print(f"Account in base is OK: {response}, {resp}") if response == "Need 2FA Code": return "Need 2FA Code" elif response == "Need Email Code": return "Need Email Code" elif response == "Rate Limit Exceeded": return "Rate Limit Exceeded" elif response == "Successfully logged in": return "Successfully logged in" except RuntimeError: pass else: try: resp = self.client.login(username=username, password=password) response = self.check_login_response(resp, username, password, account_in_base) print(f"Account not in base: {response}, {resp}") if response == "Need 2FA Code": return "Need 2FA Code" elif response == "Need Email Code": return "Need Email Code" elif response == "Rate Limit Exceeded": return "Rate Limit Exceeded" elif response == "Successfully logged in": return "Successfully logged in" except RuntimeError: pass def check_login_response(self, response, username, password, account_in_base): if response == EResult.OK: return "Successfully logged in" elif response == EResult.InvalidPassword: if account_in_base == "OK": resp = self.client.login(username=username, password=password) self.check_login_response(resp, username, password, account_in_base) else: return 'Invalid Password' elif response == EResult.AccountLoginDeniedNeedTwoFactor: return "Need 2FA Code" elif response == EResult.AccountLogonDenied: return "Need Email Code" elif response == EResult.TwoFactorCodeMismatch: return "2FA Mismatch" elif response == EResult.RateLimitExceeded: return "Rate Limit Exceeded"
class SteamNotifier(object, metaclass=Singleton): _instantiated = False _running = False _notification = None def create(self, path): if not self._instantiated: self._instantiated = True self._cache = path + '/cache/' if not os.path.exists(self._cache): os.makedirs(self._cache) # Steam Client self._steamClient = SteamClient() # Hook Steam Client Events self._steamClient.on(SteamClient.EVENT_AUTH_CODE_REQUIRED, self.auth_code_prompt) self._steamClient.on("FriendMessagesClient.IncomingMessage#1", self.handle_message) self._steamClient.on(SteamClient.EVENT_LOGGED_ON, self.login_success) self._steamClient.on(SteamClient.EVENT_CHANNEL_SECURED, self.login_secured) self._steamClient.on(SteamClient.EVENT_ERROR, self.login_error) self._steamClient.on(SteamClient.EVENT_CONNECTED, self.connected) self._steamClient.on(SteamClient.EVENT_DISCONNECTED, self.disconnected) self._steamClient.on(SteamClient.EVENT_NEW_LOGIN_KEY, self.new_login_key) # Bind EndPoints RyderClient().addEndPoint('on_connect', self._run) RyderClient().addEndPoint('steamLogin', self._steamLoginData) RyderClient().addEndPoint('steam2fa',self._steam2faData) def setupNotificationHandlerHook(self, notification): self._notification = notification def _run(self): # Start Login Sequence if not self._running: self._running = True self._steamClient.set_credential_location(self._cache) if os.path.exists(self._cache + 'steam.txt'): f = open(self._cache + 'steam.txt', 'r') data = f.readlines() f.close() gevent.spawn_later(2, SteamClient.login, self._steamClient, username=data[0].replace('\n',''), login_key=data[1]) else: if self._notification != None: self._notification('Steam', 'Login', 'Requesting Login Data') RyderClient().send("[\"steamLogin\"]") def _steamLoginData(self, data): print('Steam login data received') self._login_data = [data[1], data[2]] self._steamClient.login(username=self._login_data[0], password=self._login_data[1]) def _steam2faData(self, data): print("Steam 2FA data received") self._steamClient.login(two_factor_code=data[1], username=self._login_data[0], password=self._login_data[1]) # Handle SteamClient events def connected(self): print("Connected") def disconnected(self): print("Disconnected") if self._steamClient.relogin_available: if self._notification != None: self._notification('Steam', self._steamClient.username, 'Connection lost! Re-trying...') self._steamClient.reconnect(maxdelay=30) def login_secured(self): print("Login secured") if self._steamClient.relogin_available: self._steamClient.relogin() def login_error(self, data): print("Login error") print(data) if data == EResult.InvalidPassword: if self._notification != None: self._notification('Steam', 'Login', 'Requesting Login Data') RyderClient().send("[\"steamLogin\"]") def auth_code_prompt(self, is2fa, code_mismatch): print("Steam2FA Required") if self._notification != None: self._notification('Steam', 'Login', 'Requesting 2 Factor Authentication') RyderClient().send("[\"steam2fa\"]") def handle_message(self, msg): if msg.body.chat_entry_type == EChatEntryType.ChatMsg and not msg.body.local_echo: user = self._steamClient.get_user(msg.body.steamid_friend) text = msg.body.message if self._notification != None: self._notification('Steam', user.name, text) def login_success(self): print("Login successfull") self._steamClient.change_status(persona_state = EPersonaState.Invisible) if self._notification != None: self._notification('Steam', self._steamClient.username, 'Logged in!') def new_login_key(self): print("New login key") f = open(self._cache + 'steam.txt', 'w') f.write(self._steamClient.username + '\n' + self._steamClient.login_key) f.close()