def create_next_step(start, end):
params = {**_AUTH_PARAMS}
params['start_uri'] = start
params['end_uri_regex'] = end
return NextStep('web_session', params)
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):
show_news = self.__is_after_minor_update()
just_after_broken_sub_version = self.__is_after_broken_subscriptions_version(
) # remove after ~04.2021
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')
auth: Authentication = await self._do_auth(stored_credentials)
# To be removed around 04.2021
# After fixing bug with offline plugin for subscribers (#151),
# reconnection is need to make Galaxy recognize `get_subscriptions` feature again.
if just_after_broken_sub_version and await self._api.had_subscription(
):
show_news = True
if show_news:
self._open_config(OPTIONS_MODE.NEWS)
return auth
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())
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)
user_email = await self._fetch_marketing_data()
if show_news:
self._open_config(OPTIONS_MODE.NEWS)
return Authentication(user_id, user_email or user_id)
def test_no_stored_credentials(plugin, http_client, backend_client):
loop = asyncio.get_event_loop()
cookies = {"cookie": "value"}
user_id = "13"
persona_id = "19"
user_name = "Jan"
http_client.authenticate.return_value = None
backend_client.get_identity.return_value = user_id, persona_id, user_name
with patch.object(plugin, "store_credentials") as store_credentials:
result = loop.run_until_complete(plugin.authenticate())
assert result == NextStep("web_session", AUTH_PARAMS, js=JS)
credentials = {
"cookies": cookies,
}
result = loop.run_until_complete(
plugin.pass_login_credentials("whatever step",
"whatever credentials",
[{
"name": key,
"value": value
}
for key, value in cookies.items()]))
assert result == Authentication(user_id, user_name)
store_credentials.assert_called_with(credentials)
http_client.authenticate.assert_called_with(cookies)
backend_client.get_identity.assert_called_with()
async def test_no_stored_credentials(backend_client, plugin, cookies,
auth_info, stored_credentials, mocker):
steam_fake_cookie = Cookie(name="n", value="v")
mocker.patch.object(plugin,
"_create_two_factor_fake_cookie",
return_value=steam_fake_cookie)
assert NextStep(
"web_session",
AUTH_PARAMS,
[steam_fake_cookie],
{re.escape(LOGIN_URI): [JS_PERSISTENT_LOGIN]},
) == await plugin.authenticate()
backend_client.get_profile.return_value = PROFILE_URL
backend_client.get_profile_data.return_value = auth_info[0], auth_info[
1], auth_info[2]
store_credentials = mocker.patch.object(plugin, "store_credentials")
assert Authentication(
auth_info[0], auth_info[2]) == await plugin.pass_login_credentials(
"random step name", {
"end_uri":
"https://steamcommunity.com/id/{}/goto".format(auth_info[0])
}, cookies)
store_credentials.assert_called_with(stored_credentials)
backend_client.get_profile.assert_called_once_with()
backend_client.get_profile_data.assert_called_once_with(PROFILE_URL)
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):
stored_npsso ="DqjxBT163jkksHrOJLUZIoLnutuTnlgWpu6mgo06sOwTZRx3L4AAl1Pk1IhKeU3x"
if not stored_npsso:
return NextStep("web_session", AUTH_PARAMS)
auth_info = await self._do_auth(stored_npsso)
return auth_info
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:
return NextStep("web_session", AUTH_PARAMS)
logging.info('Stored credentials found')
user_id, user_name = await self._api.authenticate(stored_credentials)
return Authentication(user_id, user_name)
async def authenticate(self, stored_credentials: dict = None) -> Union[Authentication, NextStep]:
poesessid: Optional[PoeSessionId] = None
profile_name: Optional[ProfileName] = None
if stored_credentials:
poesessid = stored_credentials.get(self._AUTH_SESSION_ID)
profile_name = stored_credentials.get(self._AUTH_PROFILE_NAME)
if poesessid and profile_name:
return await self._do_auth(poesessid, profile_name, store_poesessid=False)
return NextStep(
"web_session"
, {
"window_title": "Still sane, exile?"
, "window_width": 800
, "window_height": 600
, "start_uri": "https://www.pathofexile.com/login"
, "end_uri_regex": re.escape(self._AUTH_REDIRECT) + ".*"
}
, js={
"https://www.pathofexile.com/my-account": [
r'''
profileName = document.getElementsByClassName("name")[0].textContent;
window.location.replace("''' + self._AUTH_REDIRECT + r'''" + profileName);
'''
]
}
)
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):
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
) -> Union[NextStep, Authentication]:
if not self.config_data['dolphin_path'] or not self.config_data[
'games_path']:
return NextStep('web_session', utils.SETUP_WEB_PARAMS)
return Authentication(
"Dolphin-ID", "Dolphin") # don't care about authentication values
async def authenticate(self, stored_credentials=None):
stored_npsso = stored_credentials.get(
"npsso") if stored_credentials else None
if not stored_npsso:
return NextStep("web_session", AUTH_PARAMS)
auth_info = await self._do_auth(stored_npsso)
return auth_info
async def authenticate(self, stored_credentials=None):
stored_cookies = stored_credentials.get(
"cookies") if stored_credentials else None
if not stored_cookies:
return NextStep("web_session", AUTH_PARAMS)
return await self._do_authenticate(stored_cookies)
async def authenticate(self, stored_credentials=None):
if not stored_credentials:
return NextStep("web_session", AUTH_PARAMS,
[self._create_two_factor_fake_cookie()],
{re.escape(LOGIN_URI): [JS_PERSISTENT_LOGIN]})
cookies = stored_credentials.get("cookies", [])
morsels = parse_stored_cookies(cookies)
return await self._do_auth(morsels)
def authenticate_using_login(self):
_URI = f'{self.blizzard_oauth_url}/authorize?response_type=code&client_id={CLIENT_ID}&redirect_uri={REDIRECT_URI}&scope=wow.profile+sc2.profile'
auth_params = {
"window_title": "Login to Battle.net",
"window_width": 540,
"window_height": 700,
"start_uri": _URI,
"end_uri_regex": r"(.*logout&app=oauth.*)|(^http://friendsofgalaxy\.com.*)"
}
return NextStep("web_session", auth_params)
async def authenticate(self, stored_credentials=None):
if stored_credentials:
stored_cookies = pickle.loads(
bytes.fromhex(stored_credentials['cookie_jar']))
self._http_client.authenticate_with_cookies(stored_cookies)
self._http_client.set_auth_lost_callback(self.lost_authentication)
acc_id = await self.paradox_client.get_account_id()
return Authentication(str(acc_id), 'Paradox')
if not stored_credentials:
return NextStep("web_session", AUTH_PARAMS)
async def authenticate(self, stored_credentials=None):
if not stored_credentials:
if await self._client.get_steamcommunity_response_status() != 200:
logger.error("Steamcommunity website not accessible")
return NextStep("web_session", AUTH_PARAMS,
[self._create_two_factor_fake_cookie()],
{re.escape(LOGIN_URI): [JS_PERSISTENT_LOGIN]})
cookies = stored_credentials.get("cookies", [])
morsels = parse_stored_cookies(cookies)
return await self._do_auth(morsels)
async def authenticate(self, stored_credentials=None):
if not stored_credentials:
PARAMS = {
"window_title": "Configure PS2 Integration",
"window_width": 550,
"window_height": 730,
"start_uri": "http://localhost:" + str(self.auth_server.port),
"end_uri_regex": ".*/end.*"
}
return NextStep("web_session", PARAMS)
return self._do_auth()
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 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 authenticate(self, stored_credentials=None):
global roms_path
if len(roms_path) == 0 and stored_credentials is not None and "roms_path" in stored_credentials:
roms_path = stored_credentials["roms_path"]
if len(roms_path) == 0:
PARAMS = {
"window_title": "Configure Dosbox Plugin",
"window_width": 400,
"window_height": 300,
"start_uri": "http://localhost:" + str(self.server.port),
"end_uri_regex": ".*/end.*"
}
return NextStep("web_session", PARAMS)
return self.finish_login()
def parse_battletag(self):
try:
battletag = self.user_details["battletag"]
except KeyError:
_URI = f'https://{self.region}.battle.net/login/en/flow/app.app?step=login&ST={requests.utils.dict_from_cookiejar(self.auth_data.cookie_jar)["BA-tassadar"]}&app=app&cr=true'
auth_params = {
"window_title": "Login to Battle.net",
"window_width": 540,
"window_height": 700,
"start_uri": _URI,
"end_uri_regex": r".*accountName.*"
}
self.attempted_to_set_battle_tag = True
return NextStep("web_session", auth_params)
self._plugin.store_credentials(self.creds)
return Authentication(self.user_details["id"], battletag)
async def test_no_stored_credentials(get_access_token, http_get, psn_plugin,
access_token, stored_credentials, npsso,
user_profile, auth_info, mocker):
assert NextStep("web_session",
AUTH_PARAMS) == await psn_plugin.authenticate()
get_access_token.return_value = access_token
http_get.return_value = user_profile
assert auth_info == await psn_plugin.pass_login_credentials(
"whatever step", {}, [{
"name": "npsso",
"value": npsso
}])
get_access_token.assert_called_once_with(npsso)
http_get.assert_called_once_with(OWN_USER_INFO_URL)
async def authenticate(self, stored_credentials=None):
if not stored_credentials:
return NextStep("web_session", AUTH_PARAMS, cookies=COOKIES)
else:
try:
user_data = await self.client.authorise_with_stored_credentials(
stored_credentials)
except AccessDenied:
raise InvalidCredentials()
except Exception as e:
log.exception(repr(e))
raise Aborted() # for sure this should be raised?
else:
self.local_client.initialize(user_data['userId'])
self.client.set_auth_lost_callback(self.auth_lost)
return Authentication(user_data['userId'],
user_data['username'])