def _check_login_social_knox_only(self, url, data):
resp = self.client.post(url, data)
self.assertEqual(resp.status_code, 200)
# check token valid
knox_auth = KnoxTokenAuthentication()
user, auth_data = knox_auth.authenticate_credentials(resp.data['token'].encode('utf8'))
self.assertEqual(user.email, self.email)
def find_token_expiration(digest):
auther = TokenAuthentication()
# XXX This is pretty wasteful since token auth can be expensive
# but should suffice until:
# https://github.com/James1345/django-rest-knox/issues/131
return auther.authenticate_credentials(
digest.encode('utf-8'))[1].expires
def get_user(access_token):
try:
auth = TokenAuthentication()
token = access_token.decode().split("access_token=")[1]
user = auth.authenticate_credentials(token.encode())
except Exception:
return AnonymousUser()
else:
return user[0]
def get_user(query_params):
close_old_connections()
knox_auth = TokenAuthentication()
try:
token = query_params.get('token', (None, ))[0]
user, auth_token = knox_auth.authenticate_credentials(
token.encode(HTTP_HEADER_ENCODING))
return user
except AuthenticationFailed:
return AnonymousUser()
def _check_login_social_knox_only(self, url, data):
try:
from knox.auth import TokenAuthentication
except ImportError:
return
resp = self.client.post(url, data)
self.assertEqual(resp.status_code, 200)
# check token valid
knox_auth = TokenAuthentication()
user, auth_data = knox_auth.authenticate_credentials(
resp.data['token'])
self.assertEqual(user.email, self.email)
def __call__(self, scope):
headers = dict(scope['headers'])
if b'authorization' in headers:
try:
knoxAuth = TokenAuthentication()
user, auth_token = knoxAuth.authenticate_credentials(
tokenString.encode(HTTP_HEADER_ENCODING))
if token_name == 'Token':
token = Token.objects.get(key=token_key)
scope['user'] = user
close_old_connections()
except auth_token.DoesNotExist:
scope['user'] = AnonymousUser()
return self.inner(scope)
def __call__(self, scope):
cookies = dict(scope['cookies'])
if 'token' in cookies:
try:
tokenString = cookies['token']
knoxAuth = TokenAuthentication()
user, auth_token = knoxAuth.authenticate_credentials(
tokenString.encode("utf-8"))
scope['user'] = user
except AuthenticationFailed:
logger.error("authentication failed!")
scope['user'] = AnonymousUser()
else:
scope['user'] = AnonymousUser()
return self.inner(scope)
def __call__(self, scope):
headers = dict(scope['headers'])
if b'sec-websocket-protocol' in headers:
try:
close_old_connections()
token_key = headers[b'sec-websocket-protocol'].decode('utf-8')
knoxAuth = TokenAuthentication()
try:
user, auth_token = knoxAuth.authenticate_credentials(
token_key.encode(HTTP_HEADER_ENCODING))
except Exception:
return self.inner(scope)
scope['user'] = user
except AuthToken.DoesNotExist:
scope['user'] = AnonymousUser()
return self.inner(scope)
def receive_json(self, content, **kwargs):
print('received message', content)
message_type = content.get('type')
if message_type is None:
self._send_error('No Message type')
return
if message_type == 'authentication':
knox_auth = TokenAuthentication()
if not isinstance(content['token'], str):
self._send_message('authentication',
state='failure',
reason='invalid token field')
else:
try:
user, auth_token = knox_auth.authenticate_credentials(
content['token'].encode('UTF-8'))
except AuthenticationFailed:
user, auth_token = None, None
if user is not None:
self._token = auth_token
self.scope['user'] = user
self._send_message('authentication', state='success')
self._on_user_authenticated(auth_token, user)
else:
self._send_message('authentication',
state='failure',
reason='invalid token')
return
if self._token is None:
self._send_error('not logged in')
return
try:
self._receive_message(message_type, content)
except Exception as e:
traceback.print_exc()
print(e)
def connect(self):
self.token = self.scope['url_route']['kwargs']['token']
self.issueID = self.scope['url_route']['kwargs']['issueID']
self.room_group_name = 'issue_' + str(self.issueID)
knoxAuth = TokenAuthentication()
user, auth_token = knoxAuth.authenticate_credentials(
self.token.encode(HTTP_HEADER_ENCODING))
if user:
try:
self.issue = Issue.objects.get(id=self.issueID)
self.user = user
async_to_sync(self.channel_layer.group_add)(
self.room_group_name, self.channel_name)
self.accept()
except Issue.DoesNotExist:
pass
def streaming_script_execute(request):
try:
form_data = json.loads(request.body.decode())
posted_token = form_data.get('token')
script_name = form_data.get('script_name')
if posted_token is not None:
token_auth = TokenAuthentication()
user, _ = token_auth.authenticate_credentials(
posted_token.encode("utf-8"))
if user.is_authenticated and user.is_superuser:
post_status = status.HTTP_200_OK
executor = ScriptExecutor(script_name)
stream = executor.stream()
response_data = {}
response_data['result'] = 'success'
response_data['message'] = 'Script update success'
for item in stream:
pass
# Check if the last item in generator is an integer
if item > 0 or item < 0:
post_status = status.HTTP_500_INTERNAL_SERVER_ERROR
response_data['result'] = 'error'
response_data['message'] = 'Failed to execute the script update'
response_data['returncode'] = item
return HttpResponse(json.dumps(response_data), content_type='application/json', status=post_status)
return redirect('/login/')
except exceptions.AuthenticationFailed:
return redirect('/login/')
except Exception as e:
handle_uncaught_error(e)
response = {'detail': f'{str(e)}'}
return HttpResponse(json.dumps(response), content_type='application/json', status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def authenticate_user(token_auth: TokenAuthentication, token: bytes):
return token_auth.authenticate_credentials(token)
