async def _do_auth(self, morsels): cookies = [(morsel.key, morsel) for morsel in morsels] self._http_client.update_cookies(cookies) self._http_client.set_cookies_updated_callback(self._store_cookies) self._force_utc() try: profile_url = await self._client.get_profile() except UnknownBackendResponse: raise InvalidCredentials() try: self._steam_id, self._miniprofile_id, login = await self._client.get_profile_data( profile_url) self.create_task(self._steam_client.run(), "Run WebSocketClient") except AccessDenied: raise InvalidCredentials() self._http_client.set_auth_lost_callback(self.lost_authentication) if "steamRememberLogin" in (cookie[0] for cookie in cookies): logger.debug("Remember login cookie present") else: logger.debug("Remember login cookie not present") return Authentication(self._steam_id, login)
async def pass_login_credentials(self, step, credentials, cookies): if "logout&app=oauth" in credentials['end_uri']: # 2fa expired, repeat authentication return self.authentication_client.authenticate_using_login() if self.authentication_client.attempted_to_set_battle_tag: self.authentication_client.user_details = await self.backend_client.get_user_info() return self.authentication_client.parse_auth_after_setting_battletag() cookie_jar = self.authentication_client.parse_cookies(cookies) auth_data = await self.authentication_client.get_auth_data_login(cookie_jar, credentials) try: await self.authentication_client.create_session() await self.backend_client.refresh_cookies() except (BackendNotAvailable, BackendError, NetworkError, UnknownError, BackendTimeout) as e: raise e except Exception: raise InvalidCredentials() auth_status = await self.backend_client.validate_access_token(auth_data.access_token) if not ("authorities" in auth_status and "IS_AUTHENTICATED_FULLY" in auth_status["authorities"]): raise InvalidCredentials() self.authentication_client.user_details = await self.backend_client.get_user_info() self.authentication_client.set_credentials() return self.authentication_client.parse_battletag()
async def _do_auth(self, npsso): if not npsso: raise InvalidCredentials() try: await self._http_client.authenticate(npsso) user_id, user_name = await self._psn_client.async_get_own_user_info() except Exception: raise InvalidCredentials() return Authentication(user_id=user_id, user_name=user_name)
def validate_auth_status(self, auth_status): if 'error' in auth_status: if not self.user_details: raise InvalidCredentials() else: return False elif not self.user_details: raise InvalidCredentials() else: if not ("authorities" in auth_status and "IS_AUTHENTICATED_FULLY" in auth_status["authorities"]): raise InvalidCredentials() return True
async def _do_auth( self, poesessid: PoeSessionId, profile_name: ProfileName, store_poesessid: bool = True ) -> Authentication: if not poesessid: raise InvalidCredentials(self._AUTH_SESSION_ID) if not profile_name: raise InvalidCredentials(self._AUTH_PROFILE_NAME) self._http_client = PoeHttpClient(poesessid, profile_name, self._on_auth_lost) if store_poesessid: self.store_credentials({self._AUTH_SESSION_ID: poesessid, self._AUTH_PROFILE_NAME: profile_name}) return Authentication(user_id=profile_name, user_name=profile_name)
async def authenticate(self, stored_credentials=None): if not stored_credentials: return NextStep( "web_session", AUTH_PARAMS, cookies=[Cookie("passedICO", "true", ".bethesda.net")], js=JS) try: log.info("Got stored credentials") cookies = pickle.loads( bytes.fromhex(stored_credentials['cookie_jar'])) cookies_parsed = [] for cookie in cookies: if cookie.key in cookies_parsed and cookie.domain: self._http_client.update_cookies( {cookie.key: cookie.value}) elif cookie.key not in cookies_parsed: self._http_client.update_cookies( {cookie.key: cookie.value}) cookies_parsed.append(cookie.key) log.info("Finished parsing stored credentials, authenticating") user = await self._http_client.authenticate() self._http_client.set_auth_lost_callback(self.lost_authentication) return Authentication(user_id=user['user_id'], user_name=user['display_name']) except (AccessDenied, Banned, UnknownError) as e: log.error( f"Couldn't authenticate with stored credentials {repr(e)}") raise InvalidCredentials()
async def authenticate(self, stored_credentials=None): logging.debug("authenticate") confirmation_uri = 'https://itch.io/user/oauth?client_id=3821cecdd58ae1a920be15f6aa479f7e&scope=profile&response_type=token&redirect_uri=http%3A%2F%2F127.0.0.1%3A7157%2Fgogg2itchintegration' if not stored_credentials: return NextStep("web_session", { "window_title": "Log in to Itch.io", "window_width": 536, "window_height": 675, "start_uri": confirmation_uri, "end_uri_regex": r"^(http://127\.0\.0\.1:7157/gogg2itchintegration#access_token=.+)", }, js={ r'^https://itch\.io/my-feed.*': [f'window.location = "{confirmation_uri}"'] }) else: self.http_client.update_cookies(stored_credentials) try: user = await self.get_user_data() return Authentication(str(user.get("id")), str(user.get("username"))) except AccessDenied: raise InvalidCredentials()
async def authenticate(self, stored_credentials=None): #check stored credentials if stored_credentials: auth_result = await self._gw2_api.do_auth_apikey(stored_credentials['api_key']) if auth_result != gw2.gw2_api.GW2AuthorizationResult.FINISHED: self.__logger.warning('authenticate: stored credentials are invalid') raise InvalidCredentials() return Authentication(self._gw2_api.get_account_id(), self._gw2_api.get_account_name()) #new auth self.__authserver = gw2.gw2_authserver.Gw2AuthServer(self._gw2_api) self.__logger.info('authenticate: no stored credentials') AUTH_PARAMS = { "window_title": "Login to Guild Wars 2", "window_width": 640, "window_height": 460, "start_uri": self.__authserver.get_uri(), "end_uri_regex": '.*finished' } if not await self.__authserver.start(): self.__logger.error('authenticate: failed to start auth server', exc_info=True) raise BackendError() return NextStep("web_session", AUTH_PARAMS)
async def authenticate(self, stored_credentials=None): logging.debug("authenticate") if not (stored_credentials.get("access_token") if stored_credentials else None): return NextStep( "web_session", { "window_title": "Log in to Itch.io", "window_width": 536, "window_height": 675, "start_uri": r"https://itch.io/user/oauth?client_id=3821cecdd58ae1a920be15f6aa479f7e&scope=profile&response_type=token&redirect_uri=http%3A%2F%2F127.0.0.1%3A7157%2Fgogg2itchintegration", "end_uri_regex": r"^http://127\.0\.0\.1:7157/gogg2itchintegration#access_token=.+", }) else: try: user = await self.get_user_data( stored_credentials["access_token"]) return Authentication(user["id"], user["username"]) except AccessDenied: raise InvalidCredentials()
async def authenticate(self, stored_credentials=None): self._http_client.create_session(stored_credentials) if not stored_credentials: return NextStep("web_session", AUTH_PARAMS) try: log.info("INFO: The credentials were successfully obtained.") cookies = pickle.loads(bytes.fromhex(stored_credentials['session_object'])).cookies log.debug("ROCKSTAR_COOKIES_FROM_HEX: " + str(cookies)) for cookie in cookies: cookie_object = { "name": cookie.name, "value": cookie.value, "domain": cookie.domain, "path": cookie.path } self._http_client.update_cookie(cookie_object) self._http_client.set_current_auth_token(stored_credentials['current_auth_token']) log.info("INFO: The stored credentials were successfully parsed. Beginning authentication...") user = await self._http_client.authenticate() return Authentication(user_id=user['rockstar_id'], user_name=user['display_name']) except Exception as e: log.warning("ROCKSTAR_AUTH_WARNING: The exception " + repr(e) + " was thrown, presumably because of " "outdated credentials. Attempting to get new credentials...") self._http_client.set_auth_lost_callback(self.lost_authentication) try: user = await self._http_client.authenticate() return Authentication(user_id=user['rockstar_id'], user_name=user['display_name']) except Exception as e: log.error("ROCKSTAR_AUTH_FAILURE: Something went terribly wrong with the re-authentication. " + repr(e)) log.exception("ROCKSTAR_STACK_TRACE") raise InvalidCredentials()
async def authenticate(self, stored_credentials=None): if not stored_credentials: logging.info('No stored credentials') AUTH_PARAMS = { "window_title": "Login to Wargaming", "window_width": 640, "window_height": 460, "start_uri": self._wgc.auth_server_uri(), "end_uri_regex": '.*finished' } if not self._wgc.auth_server_start(): raise BackendError() return NextStep("web_session", AUTH_PARAMS) else: auth_passed = self._wgc.login_info_set(stored_credentials) if not auth_passed: logging.warning('Stored credentials are invalid') raise InvalidCredentials() return Authentication( self._wgc.account_id(), '%s_%s' % (self._wgc.account_realm(), self._wgc.account_nickname()))
async def authenticate(self, stored_credentials=None): authserver = self._wgc.get_auth_server() wgni = self._wgc.get_wgni_client() if not stored_credentials: self._logger.info('plugin/authenticate: no stored credentials') AUTH_PARAMS = { "window_title": "Login to Wargaming", "window_width": 640, "window_height": 460, "start_uri": authserver.get_uri(), "end_uri_regex": '.*finished' } if not await authserver.start(): raise BackendError() return NextStep("web_session", AUTH_PARAMS) else: auth_passed = await wgni.login_info_set(stored_credentials) if not auth_passed: self._logger.warning( 'plugin/authenticate: stored credentials are invalid') raise InvalidCredentials() return Authentication( wgni.get_account_id(), '%s_%s' % (wgni.get_account_realm(), wgni.get_account_nickname()))
async def authenticate(self, stored_credentials=None): show_news = self.__is_after_minor_update() self._save_cache('last_version', __version__) if not stored_credentials: return NextStep( "web_session", { "window_title": "Login to HumbleBundle", "window_width": 560, "window_height": 610, "start_uri": "https://www.humblebundle.com/login?goto=/home/library", "end_uri_regex": "^" + re.escape("https://www.humblebundle.com/home/library") }) logging.info('Stored credentials found') user_id = await self._api.authenticate(stored_credentials) if user_id is None: raise InvalidCredentials() if show_news: self._open_config(OPTIONS_MODE.NEWS) return Authentication(user_id, user_id)
async def get_access_token(self, refresh_token=None, url=OAUTH_TOKEN_URL, cookies=None): response = None if cookies is None: cookies = {"npsso": refresh_token} try: response = await super().request("GET", url=url, cookies=cookies, allow_redirects=False) location_params = urlsplit(response.headers["Location"]) self._validate_auth_response(location_params) fragment = dict(parse_qsl(location_params.fragment)) if 'access_token' not in fragment: return await self.get_access_token( url=response.headers['Location'], cookies=response.cookies) self._store_new_npsso(cookies) return fragment["access_token"] except AuthenticationRequired as e: raise InvalidCredentials(e.data) except (KeyError, IndexError): raise UnknownBackendResponse(str(response.headers)) finally: if response: response.close()
async def authenticate(self, stored_credentials=None): if not stored_credentials: logging.info('No stored credentials') AUTH_PARAMS = { "window_title": "Login to Guild Wars 2", "window_width": 640, "window_height": 460, "start_uri": self._gw2_api.auth_server_uri(), "end_uri_regex": '.*finished' } if not self._gw2_api.auth_server_start(): raise BackendError() return NextStep("web_session", AUTH_PARAMS) else: auth_passed = self._gw2_api.do_auth_apikey( stored_credentials['api_key']) if not auth_passed: logging.warning( 'plugin/authenticate: stored credentials are invalid') raise InvalidCredentials() return Authentication(self._gw2_api.get_account_id(), self._gw2_api.get_account_name())
def parse_auth_after_setting_battletag(self): self.creds["user_details_cache"] = self.user_details try: battletag = self.user_details["battletag"] except KeyError: raise InvalidCredentials() self._plugin.store_credentials(self.creds) return Authentication(self.user_details["id"], battletag)
async def set_profile_data(profile_url): try: self._steam_id, self._miniprofile_id, login = await self._client.get_profile_data( profile_url) self.create_task(self._steam_client.run(), "Run WebSocketClient") return login except AccessDenied: raise InvalidCredentials()
async def pass_login_credentials(self, step, credentials, cookies): try: await self._http_client.authenticate_with_exchage_code( credentials["end_uri"].split(AUTH_REDIRECT_URL, 1)[1] ) except Exception: # TODO: distinguish between login-related and all other (networking, server, e.t.c.) errors raise InvalidCredentials() return await self._do_auth()
async def authenticate(self, stored_credentials=None): if not stored_credentials: log.debug("DISCORD_RESTART: Restarting Discord...") await prepare_and_discover_discord() await get_ws_url() try: await self.scrape_discord() except Exception: log.exception( "DISCORD_AUTH_FAILURE: A critical exception was thrown when scraping the Discord client." ) raise InvalidCredentials() if self.user_email: self.store_credentials({"user_email": self.user_email}) else: raise InvalidCredentials() else: self.user_email = stored_credentials["user_email"] return Authentication(self.user_email, self.user_email)
async def _do_auth(self, morsels): cookies = [(morsel.key, morsel) for morsel in morsels] self._http_client.update_cookies(cookies) self._http_client.set_cookies_updated_callback(self._store_cookies) self._force_utc() try: profile_url = await self._client.get_profile() except UnknownBackendResponse: raise InvalidCredentials() try: self._steam_id, login = await self._client.get_profile_data(profile_url) except AccessDenied: raise InvalidCredentials() self._http_client.set_auth_lost_callback(self.lost_authentication) return Authentication(self._steam_id, login)
async def pass_login_credentials(self, step, credentials, cookies): self._gw2_api.auth_server_stop() api_key = self._gw2_api.get_api_key() if not api_key: logging.error('plugin/pass_login_credentials: api_key is None!') raise InvalidCredentials() self.store_credentials({'api_key': api_key}) return Authentication(self._gw2_api.get_account_id(), self._gw2_api.get_account_name())
async def set_profile_data(): try: await self._client.get_authentication_data() steam_id, login = await self._client.get_profile_data(profile_url) self._user_info_cache.account_username = login self._user_info_cache.old_flow = True self._user_info_cache.steam_id = steam_id self.create_task(self._steam_client.run(), "Run WebSocketClient") return steam_id, login except AccessDenied: raise InvalidCredentials()
async def _do_authenticate(self, cookies): try: await self._http_client.authenticate(cookies) self._user_id, self._persona_id, user_name = await self._backend_client.get_identity( ) return Authentication(self._user_id, user_name) except (AccessDenied, InvalidCredentials, AuthenticationRequired) as e: logging.exception("Failed to authenticate %s", repr(e)) raise InvalidCredentials()
async def authenticate(self, stored_credentials=None): if not stored_credentials: return NextStep("web_session", AUTH_PARAMS, js=AUTH_JS) refresh_token = stored_credentials["refresh_token"] try: await self._http_client.authenticate_with_refresh_token(refresh_token) except Exception: # TODO: distinguish between login-related and all other (networking, server, e.t.c.) errors raise InvalidCredentials() return await self._do_auth()
async def pass_login_credentials(self, step, credentials, cookies): self._wgc.auth_server_stop() login_info = self._wgc.login_info_get() if not login_info: logging.error('Login info is None!') raise InvalidCredentials() self.store_credentials(login_info) return Authentication( self._wgc.account_id(), '%s_%s' % (self._wgc.account_realm(), self._wgc.account_nickname()))
async def start(rec_tries=0): if rec_tries > 100: log.debug( "DISCORD_SCRAPE_FAILED: The maximum number of retries has been reached." ) raise InvalidCredentials() global returned_from_trio_run # await trio.sleep(10) ws = websocket.WebSocket() ws.connect(ws_url) returned_from_trio_run = (await get_games(ws), await get_friends(ws), await get_user_email(ws))
async def pass_login_credentials(self, step, credentials, cookies): if self.__authserver is not None: await self.__authserver.shutdown() api_key = self._gw2_api.get_api_key() account_id = self._gw2_api.get_account_id() account_name = self._gw2_api.get_account_name() if (api_key is None) or (account_id is None) or (account_name is None): self.__logger.error('pass_login_credentials: invalid credentials') raise InvalidCredentials() self.store_credentials({'api_key': api_key}) return Authentication(account_id, account_name)
async def authenticate(self, stored_credentials=None): if not stored_credentials: return NextStep("web_session", AUTH_PARAMS) refresh_token = stored_credentials["refresh_token"] try: await self._http_client.authenticate_with_refresh_token(refresh_token) except (BackendNotAvailable, BackendError, BackendTimeout, NetworkError, UnknownError) as e: raise e except Exception: raise InvalidCredentials() return await self._do_auth()
async def _do_authenticate(self, cookies): try: await self._http_client.authenticate(cookies) self._pid, self._persona_id, user_name = await self._backend_client.get_identity( ) return Authentication(self._pid, user_name) except (BackendNotAvailable, BackendTimeout, BackendError): raise except Exception: # TODO: more precise error reason logging.exception("Authentication failed") raise InvalidCredentials()
async def do_request(self, method, *args, **kwargs): try: return await self.request(method, *args, **kwargs) except Exception as e: log.warning( f"Request failed with {repr(e)}, attempting to refresh credentials" ) try: await self.refresh_credentials() return await self.request(method, *args, **kwargs) except Exception as e: log.error(f"Refresh workflow failed with {repr(e)}") self._auth_lost_callback() raise InvalidCredentials()