django-rest-framework/rest_framework/authentication.py

359 lines
12 KiB
Python
Raw Normal View History

"""
2013-04-25 15:47:34 +04:00
Provides various authentication policies.
"""
2013-02-01 18:03:28 +04:00
from __future__ import unicode_literals
import base64
from django.contrib.auth import authenticate
from django.core.exceptions import ImproperlyConfigured
from django.conf import settings
2013-02-01 18:03:28 +04:00
from rest_framework import exceptions, HTTP_HEADER_ENCODING
from rest_framework.compat import CsrfViewMiddleware
2013-03-07 13:01:53 +04:00
from rest_framework.compat import oauth, oauth_provider, oauth_provider_store
from rest_framework.compat import oauth2_provider, provider_now, check_nonce
from rest_framework.authtoken.models import Token
2013-03-09 00:23:11 +04:00
def get_authorization_header(request):
"""
Return request's 'Authorization:' header, as a bytestring.
Hide some test client ickyness where the header can be unicode.
"""
auth = request.META.get('HTTP_AUTHORIZATION', b'')
if type(auth) == type(''):
# Work around django test client oddness
auth = auth.encode(HTTP_HEADER_ENCODING)
return auth
class CSRFCheck(CsrfViewMiddleware):
def _reject(self, request, reason):
# Return the failure reason instead of an HttpResponse
return reason
class BaseAuthentication(object):
"""
All authentication classes should extend BaseAuthentication.
"""
def authenticate(self, request):
"""
2012-10-15 16:27:50 +04:00
Authenticate the request and return a two-tuple of (user, token).
"""
2012-10-15 16:27:50 +04:00
raise NotImplementedError(".authenticate() must be overridden.")
2012-10-17 17:59:53 +04:00
def authenticate_header(self, request):
"""
Return a string to be used as the value of the `WWW-Authenticate`
header in a `401 Unauthenticated` response, or `None` if the
authentication scheme should return `403 Permission Denied` responses.
"""
pass
class BasicAuthentication(BaseAuthentication):
"""
2012-10-15 16:27:50 +04:00
HTTP Basic authentication against username/password.
"""
2012-11-13 15:27:09 +04:00
www_authenticate_realm = 'api'
def authenticate(self, request):
"""
Returns a `User` if a correct username and password have been supplied
using HTTP Basic authentication. Otherwise returns `None`.
"""
2013-03-09 00:23:11 +04:00
auth = get_authorization_header(request).split()
2012-11-13 15:27:09 +04:00
2013-02-01 18:03:28 +04:00
if not auth or auth[0].lower() != b'basic':
2012-11-13 15:27:09 +04:00
return None
2013-03-09 00:23:11 +04:00
if len(auth) == 1:
msg = 'Invalid basic header. No credentials provided.'
2013-03-09 02:56:24 +04:00
raise exceptions.AuthenticationFailed(msg)
elif len(auth) > 2:
2013-03-09 00:23:11 +04:00
msg = 'Invalid basic header. Credentials string should not contain spaces.'
raise exceptions.AuthenticationFailed(msg)
2012-11-13 15:27:09 +04:00
try:
2013-02-01 18:03:28 +04:00
auth_parts = base64.b64decode(auth[1]).decode(HTTP_HEADER_ENCODING).partition(':')
except (TypeError, UnicodeDecodeError):
2013-03-09 00:23:11 +04:00
msg = 'Invalid basic header. Credentials not correctly base64 encoded'
raise exceptions.AuthenticationFailed(msg)
2012-11-13 15:27:09 +04:00
2013-03-07 13:01:53 +04:00
userid, password = auth_parts[0], auth_parts[2]
2012-11-13 15:27:09 +04:00
return self.authenticate_credentials(userid, password)
def authenticate_credentials(self, userid, password):
"""
Authenticate the userid and password against username and password.
"""
user = authenticate(username=userid, password=password)
2013-03-09 00:23:11 +04:00
if user is None or not user.is_active:
raise exceptions.AuthenticationFailed('Invalid username/password')
return (user, None)
2012-11-13 15:27:09 +04:00
2013-01-22 01:29:49 +04:00
def authenticate_header(self, request):
2012-11-13 15:27:09 +04:00
return 'Basic realm="%s"' % self.www_authenticate_realm
class SessionAuthentication(BaseAuthentication):
"""
Use Django's session framework for authentication.
"""
def authenticate(self, request):
"""
2012-10-15 16:27:50 +04:00
Returns a `User` if the request session currently has a logged in user.
Otherwise returns `None`.
"""
2012-10-10 19:36:25 +04:00
# Get the underlying HttpRequest object
2013-06-30 00:34:47 +04:00
request = request._request
user = getattr(request, 'user', None)
# Unauthenticated, CSRF validation not required
if not user or not user.is_active:
2012-11-13 15:27:09 +04:00
return None
2013-06-30 00:34:47 +04:00
self.enforce_csrf(request)
# CSRF passed with authenticated user
return (user, None)
def enforce_csrf(self, request):
"""
Enforce CSRF validation for session based authentication.
"""
reason = CSRFCheck().process_view(request, None, (), {})
if reason:
# CSRF failed, bail with explicit error message
2012-11-13 15:27:09 +04:00
raise exceptions.AuthenticationFailed('CSRF Failed: %s' % reason)
class TokenAuthentication(BaseAuthentication):
"""
Simple token based authentication.
Clients should authenticate by passing the token key in the "Authorization"
HTTP header, prepended with the string "Token ". For example:
Authorization: Token 401f7ac837da42b97f613d789819ff93537bee6a
"""
model = Token
"""
A custom token model may be used, but must have the following properties.
* key -- The string identifying the token
* user -- The user to which the token belongs
"""
def authenticate(self, request):
2013-03-09 00:23:11 +04:00
auth = get_authorization_header(request).split()
2013-03-09 02:56:24 +04:00
if not auth or auth[0].lower() != b'token':
2012-11-13 15:27:09 +04:00
return None
2013-03-09 00:23:11 +04:00
if len(auth) == 1:
msg = 'Invalid token header. No credentials provided.'
2013-03-09 02:56:24 +04:00
raise exceptions.AuthenticationFailed(msg)
elif len(auth) > 2:
2013-03-09 00:23:11 +04:00
msg = 'Invalid token header. Token string should not contain spaces.'
raise exceptions.AuthenticationFailed(msg)
2012-11-13 15:27:09 +04:00
return self.authenticate_credentials(auth[1])
def authenticate_credentials(self, key):
try:
token = self.model.objects.get(key=key)
except self.model.DoesNotExist:
raise exceptions.AuthenticationFailed('Invalid token')
2013-03-09 00:23:11 +04:00
if not token.user.is_active:
raise exceptions.AuthenticationFailed('User inactive or deleted')
return (token.user, token)
2012-11-13 15:27:09 +04:00
2013-01-22 01:29:49 +04:00
def authenticate_header(self, request):
2012-11-13 15:27:09 +04:00
return 'Token'
2013-02-25 19:58:16 +04:00
class OAuthAuthentication(BaseAuthentication):
2013-03-07 13:01:53 +04:00
"""
OAuth 1.0a authentication backend using `django-oauth-plus` and `oauth2`.
Note: The `oauth2` package actually provides oauth1.0a support. Urg.
2013-03-07 19:44:36 +04:00
We import it from the `compat` module as `oauth`.
2013-03-07 13:01:53 +04:00
"""
2013-02-25 19:58:16 +04:00
www_authenticate_realm = 'api'
2013-03-09 00:23:11 +04:00
def __init__(self, *args, **kwargs):
super(OAuthAuthentication, self).__init__(*args, **kwargs)
2013-02-25 19:58:16 +04:00
if oauth is None:
2013-03-07 19:44:36 +04:00
raise ImproperlyConfigured(
"The 'oauth2' package could not be imported."
"It is required for use with the 'OAuthAuthentication' class.")
2013-02-25 19:58:16 +04:00
if oauth_provider is None:
2013-03-07 19:44:36 +04:00
raise ImproperlyConfigured(
"The 'django-oauth-plus' package could not be imported."
"It is required for use with the 'OAuthAuthentication' class.")
2013-02-25 19:58:16 +04:00
def authenticate(self, request):
"""
2013-03-07 13:01:53 +04:00
Returns two-tuple of (user, token) if authentication succeeds,
or None otherwise.
2013-02-25 19:58:16 +04:00
"""
2013-03-07 19:44:36 +04:00
try:
oauth_request = oauth_provider.utils.get_oauth_request(request)
except oauth.Error as err:
raise exceptions.AuthenticationFailed(err.message)
if not oauth_request:
return None
2013-03-07 19:44:36 +04:00
oauth_params = oauth_provider.consts.OAUTH_PARAMETERS_NAMES
found = any(param for param in oauth_params if param in oauth_request)
missing = list(param for param in oauth_params if param not in oauth_request)
if not found:
# OAuth authentication was not attempted.
2013-03-07 13:01:53 +04:00
return None
2013-02-25 19:58:16 +04:00
2013-03-07 19:44:36 +04:00
if missing:
# OAuth was attempted but missing parameters.
msg = 'Missing parameters: %s' % (', '.join(missing))
raise exceptions.AuthenticationFailed(msg)
2013-02-25 19:58:16 +04:00
2013-03-07 13:01:53 +04:00
if not self.check_nonce(request, oauth_request):
2013-03-07 19:44:36 +04:00
msg = 'Nonce check failed'
raise exceptions.AuthenticationFailed(msg)
2013-02-25 19:58:16 +04:00
2013-03-07 13:01:53 +04:00
try:
consumer_key = oauth_request.get_parameter('oauth_consumer_key')
consumer = oauth_provider_store.get_consumer(request, oauth_request, consumer_key)
except oauth_provider.store.InvalidConsumerError:
msg = 'Invalid consumer token: %s' % oauth_request.get_parameter('oauth_consumer_key')
raise exceptions.AuthenticationFailed(msg)
2013-02-25 19:58:16 +04:00
2013-03-07 13:01:53 +04:00
if consumer.status != oauth_provider.consts.ACCEPTED:
msg = 'Invalid consumer key status: %s' % consumer.get_status_display()
raise exceptions.AuthenticationFailed(msg)
2013-02-25 19:58:16 +04:00
2013-03-07 13:01:53 +04:00
try:
token_param = oauth_request.get_parameter('oauth_token')
token = oauth_provider_store.get_access_token(request, oauth_request, consumer, token_param)
except oauth_provider.store.InvalidTokenError:
2013-03-07 13:01:53 +04:00
msg = 'Invalid access token: %s' % oauth_request.get_parameter('oauth_token')
raise exceptions.AuthenticationFailed(msg)
2013-02-25 19:58:16 +04:00
2013-03-07 13:01:53 +04:00
try:
self.validate_token(request, consumer, token)
2013-03-07 13:15:05 +04:00
except oauth.Error as err:
raise exceptions.AuthenticationFailed(err.message)
2013-02-25 19:58:16 +04:00
2013-03-07 13:01:53 +04:00
user = token.user
2013-02-25 19:58:16 +04:00
2013-03-07 13:01:53 +04:00
if not user.is_active:
2013-03-07 19:44:36 +04:00
msg = 'User inactive or deleted: %s' % user.username
raise exceptions.AuthenticationFailed(msg)
2013-02-25 19:58:16 +04:00
2013-03-07 13:01:53 +04:00
return (token.user, token)
2013-02-25 19:58:16 +04:00
def authenticate_header(self, request):
"""
2013-03-07 19:44:36 +04:00
If permission is denied, return a '401 Unauthorized' response,
with an appropraite 'WWW-Authenticate' header.
2013-02-25 19:58:16 +04:00
"""
2013-03-07 19:44:36 +04:00
return 'OAuth realm="%s"' % self.www_authenticate_realm
2013-02-25 19:58:16 +04:00
2013-03-07 19:44:36 +04:00
def validate_token(self, request, consumer, token):
2013-02-25 19:58:16 +04:00
"""
2013-03-07 19:44:36 +04:00
Check the token and raise an `oauth.Error` exception if invalid.
2013-02-25 19:58:16 +04:00
"""
oauth_server, oauth_request = oauth_provider.utils.initialize_server_request(request)
2013-03-07 19:44:36 +04:00
oauth_server.verify_request(oauth_request, consumer, token)
2013-02-25 19:58:16 +04:00
2013-03-07 13:01:53 +04:00
def check_nonce(self, request, oauth_request):
2013-02-25 19:58:16 +04:00
"""
2013-03-07 19:44:36 +04:00
Checks nonce of request, and return True if valid.
2013-02-25 19:58:16 +04:00
"""
oauth_nonce = oauth_request['oauth_nonce']
oauth_timestamp = oauth_request['oauth_timestamp']
return check_nonce(request, oauth_request, oauth_nonce, oauth_timestamp)
2013-03-07 21:43:13 +04:00
2013-03-01 05:08:58 +04:00
class OAuth2Authentication(BaseAuthentication):
"""
OAuth 2 authentication backend using `django-oauth2-provider`
"""
2013-03-09 00:23:11 +04:00
www_authenticate_realm = 'api'
allow_query_params_token = settings.DEBUG
2013-03-09 00:23:11 +04:00
def __init__(self, *args, **kwargs):
super(OAuth2Authentication, self).__init__(*args, **kwargs)
2013-03-01 05:08:58 +04:00
if oauth2_provider is None:
2013-03-09 00:23:11 +04:00
raise ImproperlyConfigured(
"The 'django-oauth2-provider' package could not be imported. "
"It is required for use with the 'OAuth2Authentication' class.")
2013-03-01 05:08:58 +04:00
def authenticate(self, request):
"""
2013-03-09 00:23:11 +04:00
Returns two-tuple of (user, token) if authentication succeeds,
or None otherwise.
2013-03-01 05:08:58 +04:00
"""
2013-03-09 00:23:11 +04:00
auth = get_authorization_header(request).split()
if auth and auth[0].lower() == b'bearer':
access_token = auth[1]
elif 'access_token' in request.POST:
access_token = request.POST['access_token']
elif 'access_token' in request.GET and self.allow_query_params_token:
access_token = request.GET['access_token']
else:
2013-03-09 00:23:11 +04:00
return None
if len(auth) == 1:
msg = 'Invalid bearer header. No credentials provided.'
2013-03-09 02:56:24 +04:00
raise exceptions.AuthenticationFailed(msg)
elif len(auth) > 2:
2013-03-09 00:23:11 +04:00
msg = 'Invalid bearer header. Token string should not contain spaces.'
raise exceptions.AuthenticationFailed(msg)
2013-03-01 05:08:58 +04:00
return self.authenticate_credentials(request, access_token)
2013-03-01 05:08:58 +04:00
def authenticate_credentials(self, request, access_token):
"""
2013-03-09 00:23:11 +04:00
Authenticate the request, given the access token.
2013-03-01 05:08:58 +04:00
"""
try:
token = oauth2_provider.oauth2.models.AccessToken.objects.select_related('user')
# provider_now switches to timezone aware datetime when
# the oauth2_provider version supports to it.
token = token.get(token=access_token, expires__gt=provider_now())
except oauth2_provider.oauth2.models.AccessToken.DoesNotExist:
raise exceptions.AuthenticationFailed('Invalid token')
2013-03-01 05:08:58 +04:00
user = token.user
if not user.is_active:
2013-03-09 00:23:11 +04:00
msg = 'User inactive or deleted: %s' % user.username
raise exceptions.AuthenticationFailed(msg)
2013-03-01 05:08:58 +04:00
return (user, token)
2013-03-01 05:08:58 +04:00
def authenticate_header(self, request):
"""
2013-03-07 21:43:13 +04:00
Bearer is the only finalized type currently
2013-03-01 05:08:58 +04:00
Check details on the `OAuth2Authentication.authenticate` method
"""
2013-03-09 00:23:11 +04:00
return 'Bearer realm="%s"' % self.www_authenticate_realm