def test_authorization_url(self):
flow_obj = DropboxOAuth2Flow(APP_KEY, APP_SECRET,
'http://localhost/dummy', 'dummy_session',
'dbx-auth-csrf-token')
for redirect_uri in [None, 'localhost']:
for state in [None, 'state']:
for token_access_type in [None, 'legacy', 'offline', 'online']:
for scope in [None, SCOPE_LIST]:
for include_granted_scopes in [None, 'user', 'team']:
for code_challenge in [None, 'mychallenge']:
authorization_url = \
flow_obj._get_authorize_url(redirect_uri, state,
token_access_type, scope,
include_granted_scopes,
code_challenge)
assert authorization_url\
.startswith('https://{}/oauth2/authorize?'
.format(session.WEB_HOST))
assert 'client_id={}'.format(
APP_KEY) in authorization_url
assert 'response_type=code' in authorization_url
if redirect_uri:
assert 'redirect_uri={}'.format(redirect_uri) \
in authorization_url
else:
assert 'redirect_uri' not in authorization_url
if state:
assert 'state={}'.format(
state) in authorization_url
else:
assert 'state' not in authorization_url
if token_access_type:
assert 'token_access_type={}'.format(token_access_type) \
in authorization_url
else:
assert 'token_access_type' not in authorization_url
if scope:
assert 'scope={}'.format("+".join(scope)) \
in authorization_url
else:
assert 'scope' not in authorization_url
if include_granted_scopes and scope:
assert 'include_granted_scopes={}'\
.format(include_granted_scopes)\
in authorization_url
else:
assert 'include_granted_scopes' not in authorization_url
if code_challenge:
assert 'code_challenge_method=S256' in authorization_url
assert 'code_challenge={}'.format(code_challenge)\
in authorization_url
else:
assert 'code_challenge_method' not in authorization_url
assert 'code_challenge' not in authorization_url
def get_dropbox_auth_flow():
redirect_uri = url_for('dropbox_auth_finish', _external=True)
j = utils.load_json(_PTH_DB_SECRET_CONFIG)
return DropboxOAuth2Flow(j["APP_KEY"], j["APP_SECRET"], redirect_uri,
session, "dropbox-auth-csrf-token")
def get_flow():
return DropboxOAuth2Flow(
APP_KEY,
APP_SECRET,
get_url('oauth_callback'),
session,
'dropbox-csrf-token')
def dropbox_auth_flow(session):
return DropboxOAuth2Flow(consumer_key=conf.APP_KEY,
redirect_uri=REDIRECT_URI,
consumer_secret=conf.APP_SECRET,
token_access_type="offline",
session=session,
csrf_token_session_key="dropbox-auth-csrf-token")
def get_dropbox_auth_flow(web_app_session):
"""
获取 Dropbox Auth 验证流
"""
DropboxOAuth2Flow(DROPBOX_KEY,
DROPBOX_SECRET,
DP_REDIRECT_URL)
def test_authorization_url_legacy_default(self):
flow_obj = DropboxOAuth2Flow(APP_KEY, APP_SECRET, 'http://localhost/dummy',
'dummy_session', 'dbx-auth-csrf-token')
legacy_default_authorization_url = flow_obj._get_authorize_url(None, None, 'legacy')
assert legacy_default_authorization_url.startswith('https://{}/oauth2/authorize?'
.format(session.WEB_HOST))
assert 'client_id={}'.format(APP_KEY) in legacy_default_authorization_url
assert 'response_type=code' in legacy_default_authorization_url
def client(self, request):
redirect_uri = reverse('dropbox_integration:oauth2_callback')
oauth = DropboxOAuth2Flow(
consumer_key=settings.DROPBOX_APP_KEY,
consumer_secret=settings.DROPBOX_APP_SECRET,
redirect_uri=request.build_absolute_uri(redirect_uri),
session=request.session['dropbox'],
csrf_token_session_key='state')
return Dropbox(oauth.access_token)
def test_authorization_url_with_scopes(self):
flow_obj = DropboxOAuth2Flow(APP_KEY, APP_SECRET, 'http://localhost/dummy',
'dummy_session', 'dbx-auth-csrf-token')
scopes = ['account_info.read', 'files.metadata.read']
scope_authorization_url = flow_obj._get_authorize_url(None, None, 'offline', scopes)
assert scope_authorization_url.startswith('https://{}/oauth2/authorize?'
.format(session.WEB_HOST))
assert 'client_id={}'.format(APP_KEY) in scope_authorization_url
assert 'response_type=code' in scope_authorization_url
assert 'token_access_type=offline' in scope_authorization_url
assert 'scope=account_info.read+files.metadata.read' in scope_authorization_url
assert 'include_granted_scopes' not in scope_authorization_url
def _initialize(self):
self._csrf = u_b64enc(urandom(32))
appid = self._oauth_config.app_id
secret = self._oauth_config.app_secret
log.debug('Initializing Dropbox. manual_mode=%s',
self._oauth_config.manual_mode)
if not appid and secret:
self.disconnect()
raise CloudTokenError("require app key and secret")
if not self._oauth_config.manual_mode:
try:
self._oauth_config.start_server(
on_success=self._on_oauth_success,
on_failure=self._on_oauth_failure,
)
self._flow = DropboxOAuth2Flow(
consumer_key=appid,
consumer_secret=secret,
redirect_uri=self._oauth_config.redirect_uri + "auth/",
session=self._session,
csrf_token_session_key=self._csrf,
locale=None)
except Exception as e:
log.exception('Unable to start oauth')
self.disconnect()
raise CloudTokenError("failed to start oauth: %s" % repr(e))
else:
self._flow = DropboxOAuth2Flow(consumer_key=appid,
consumer_secret=secret,
redirect_uri=self._redir,
session=self._session,
csrf_token_session_key=self._csrf,
locale=None)
url = self._flow.start()
self._oauth_config.authorization_url = url # pragma: no cover
webbrowser.open(url)
return url
def get_dropbox_auth_flow(self):
if os.environ.get('PORT'):
# Use HTTPS redirect URL in production
base = 'https://kindleclips.herokuapp.com'
else:
# Standard HTTP for localhost
base = None
redirect_uri = cherrypy.url('/setup', base=base)
web_app_session = cherrypy.session
return DropboxOAuth2Flow(DROPBOX_KEY, DROPBOX_SECRET, redirect_uri,
web_app_session, 'dropbox-auth-csrf-token')
def authorization(self):
"""
oauth2
:return:
"""
auth_flow = DropboxOAuth2Flow(self.APP_KEY, self.APP_SECRET, redirect_uri=config['redirect']['url'], session={},
csrf_token_session_key=self.csrf_token_session_key)
authorize_url = auth_flow.start()
self.state = parse_qs(urlparse(authorize_url).query)['state'][0]
webbrowser.open(authorize_url)
if not self.get_auth_tocken():
print('Authorization failed')
return False
self.access_token = auth_flow.finish(self.access_parameters)
self.dbx = dropbox.Dropbox(self.access_token.access_token)
self.dfx = dropbox.files
return True
def oauth_flow(self):
if 'oauth_states' not in session.data:
session.data['oauth_states'] = {}
if self.short_name not in session.data['oauth_states']:
session.data['oauth_states'][self.short_name] = {
'state': generate_token()
}
return DropboxOAuth2Flow(
self.client_id,
self.client_secret,
redirect_uri=web_url_for(
'oauth_callback',
service_name=self.short_name,
_absolute=True
),
session=session.data['oauth_states'][self.short_name], csrf_token_session_key='state'
)
def test_default_oauth2_urls(self):
flow_obj = DropboxOAuth2Flow('dummy_app_key', 'dummy_app_secret',
'http://localhost/dummy', 'dummy_session', 'dbx-auth-csrf-token')
six.assertRegex(
self,
flow_obj._get_authorize_url('http://localhost/redirect', 'state', 'legacy'),
r'^https://{}/oauth2/authorize\?'.format(re.escape(session.WEB_HOST)),
)
self.assertEqual(
flow_obj.build_url('/oauth2/authorize'),
'https://{}/oauth2/authorize'.format(session.API_HOST),
)
self.assertEqual(
flow_obj.build_url('/oauth2/authorize', host=session.WEB_HOST),
'https://{}/oauth2/authorize'.format(session.WEB_HOST),
)
def get(self, request):
flow = DropboxOAuth2Flow(
settings.DROPBOX_API_KEY,
settings.DROPBOX_API_SECRET,
request.build_absolute_uri(
'%s?%s' % (
reverse('dropbox_callback'),
urlencode(
{
'next': (
self.request.GET.get('next') or
settings.LOGIN_REDIRECT_URL
)
}
)
)
),
request.session,
'csrfmiddlewaretoken'
)
return HttpResponseRedirect(
flow.start()
)
def get_dropbox_auth_flow(web_app_session):
redirect_url = ST.REDIRECT_URL
DropboxOAuth2Flow(ST.APP_KEY, ST.APP_SECRET, redirect_url)
def get_dropbox_auth_flow(request):
proto = 'https://' if request.is_secure() else 'http://'
redirect_uri = proto + request.META['HTTP_HOST'] + resolve_url('dropboxauthredirect')
return DropboxOAuth2Flow(settings.DROPBOX_APP_KEY, settings.DROPBOX_APP_SECRET,
redirect_uri, request.session, "dropbox-auth-csrf-token")
def get_dropbox_auth_flow(web_app_session):
redirect_uri = "http://localhost:8000/zapier/index/"
return DropboxOAuth2Flow("wz86r6znb1z42dh", "yw5gf9vfxb5leof",
redirect_uri, web_app_session,
"dropbox-auth-csrf-token")
def test_authorization_url_invalid_token_type_raises_assertion_error(self):
flow_obj = DropboxOAuth2Flow(APP_KEY, APP_SECRET,
'http://localhost/dummy', 'dummy_session',
'dbx-auth-csrf-token')
with pytest.raises(AssertionError):
flow_obj._get_authorize_url(None, None, 'invalid')
def get_dropbox_auth_flow(web_app_session):
redirect_uri = url_for('settings.dropbox_auth_finish', _external=True)
return DropboxOAuth2Flow(app.config["DROPBOX_APP_KEY"],
app.config["DROPBOX_APP_SECRET"], redirect_uri,
web_app_session, "dropbox-auth-csrf-token")
def get_dropbox_auth_flow(web_app_session):
redirect_uri = "https://my-web-server.org/dropbox-auth-finish"
return DropboxOAuth2Flow(
'0azi3qhn16dgofm', 'trpjwzdmwqo0wd9', redirect_uri, web_app_session,
"dropbox-auth-csrf-token")
def get_dropbox_auth_flow(web_app_session):
return DropboxOAuth2Flow("APP_KEY", "APP_SECRET", root + ":" + str(port),
web_app_session, "dropbox-auth-csrf-token")
def get_dropbox_auth_flow(web_app_session):
return DropboxOAuth2Flow(APP_KEY, APP_SECRET, DP_REDIRECT_URL,
web_app_session, "dropbox-auth-csrf-token")
def get_flow():
print("GETTING FLOW...")
return DropboxOAuth2Flow(APP_KEY, APP_SECRET, get_url('oauth_callback'),
session, 'dropbox-csrf-token')
def get_dropbox_auth_flow(web_app_session):
return DropboxOAuth2Flow(settings.DROPBOX_APP_KEY,
settings.DROPBOX_APP_SECRET,
settings.DROPBOX_CLIENT_REDIRECT_URI,
web_app_session, "dropbox-auth-csrf-token")
def get_dropbox_auth_flow(web_app_session):
return DropboxOAuth2Flow(
os.environ["COUCHDROP_WEB__DROPBOX_KEY"], os.environ["COUCHDROP_WEB__DROPBOX_SECRET"],
os.environ["COUCHDROP_WEB__REDIRECT_URI"], web_app_session,
"dropbox-auth-csrf-token"
)
def get_dropbox_auth_flow(web_app_session):
return DropboxOAuth2Flow(DROPBOX_APP_KEY, DROPBOX_APP_SECRET,
DROPBOX_APP_REDIRECT, web_app_session,
"dropbox-auth-csrf-token")
