drf之三大认证

Posted 2021-03-07 ghostant

一、前言

? 我们知道drf的APIView类的as_view直接对原生django的csrf进行了禁用，是什么让drf有如此底气？从之前对drf的源码分析可以看到，三条语句。

self.perform_authentication(request)
self.check_permissions(request)
self.check_throttles(request)

这就是drf的三大认证。

二、用户认证

1.drf的用户认证

? 我们的某些接口需要对用户进行辨别，那么我们该如何区分A用户和B用户呢？如果A用户想访问B用户的余额，这种操作是不被允许的。在django中，已经完成过基于cookie和session的身份认证，对登录的用户返回一个cookie，并在服务端也进行保存，用户必须携带cookie才能通过用户认证。

drf的认证规则：

• 如果没有认证信息，则认为是游客
• 如果认证失败，抛出异常
• 认证成功返回（user，token）

rest_framework文件下的authentication.py中为我们写好了用户认证的基类，及一些基础的认证类。我们可以通过重写authenticate和相关的方法来定义自己的用户认证类。

class BaseAuthentication:
    """
    All authentication classes should extend BaseAuthentication.
    """

    def authenticate(self, request):
        """
        Authenticate the request and return a two-tuple of (user, token).
        """
        raise NotImplementedError(".authenticate() must be overridden.")

    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

2.基于token的drf-jwt认证

? 我们借用第三方djangorestframework-jwt来完成我们的用户认证。jwt是通过签发token、校验token来完成用户认证的。token是有 头、体、签名信息组成的一串字符串，以 . 分割开。

'''
token示例eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoyLCJ1c2VybmFtZSI6ImN5YW4iLCJleHAiOjE1ODI1NDA0MDcsImVtYWlsIjoiIn0.52E5R00GL0gx-3O3OTosXz0cDWmVzmNU16xEbZpmAkg

1.头和体部一般可以是一个字典序列化成Json格式后转化为二进制然后进行 双向加密如：base64算法得到的。
2.头部信息一般只是对token的所属进行声明，例如项目名称、公司名称
3.体部信息则包含用户的标识信息、及关键信息，如用户的主键、用户的设备信息、token的有效时间、token的签发时间。服务端可以通过对其进行反向解密获得相关信息。
4.尾部信息由 经过加密后的头部和尾部 与 服务器存储的秘钥 进行单向加密如：md5算法生成。

分析：服务端拿到token后会对 头、体及自身存储的秘钥进行md5加密，如果加密的结果与第三段不符，则一定是头、体的信息发生了改变，token便会认为无效。所以服务器端的秘钥是至关重要的，如果泄漏了则攻击者可以伪造任意的token对任意的接口进行访问。
优势：服务端不用再保存用户的认证信息，也就意味着不需要频繁的读写数据库，降低了数据库的压力，在实现服务器集群时也非常方便。
'''

jwtauthentication源码分析

# from rest_framework_jwt.authentication.JSONWebTokenAuthentication类中
class BaseJSONWebTokenAuthentication(BaseAuthentication):
    """
    Token based authentication using the JSON Web Token standard.
    """

    def authenticate(self, request):
        """
        Returns a two-tuple of `User` and token if a valid signature has been
        supplied using JWT-based authentication.  Otherwise returns `None`.
        """
        # 获取request请求中的token
        jwt_value = self.get_jwt_value(request)
        if jwt_value is None:
            return None
        
        # 对token进碰撞校验:编码格式、过期时间、token是否有效
        try:
            payload = jwt_decode_handler(jwt_value)
        except jwt.ExpiredSignature:
            msg = _('Signature has expired.')
            raise exceptions.AuthenticationFailed(msg)
        except jwt.DecodeError:
            msg = _('Error decoding signature.')
            raise exceptions.AuthenticationFailed(msg)
        except jwt.InvalidTokenError:
            raise exceptions.AuthenticationFailed()
        
        # 获取token中包含的user对象
        user = self.authenticate_credentials(payload)

        return (user, jwt_value)

    def authenticate_credentials(self, payload):
        """
        Returns an active user that matches the payload's user id and email.
        """
        User = get_user_model()
        username = jwt_get_username_from_payload(payload)

        if not username:
            msg = _('Invalid payload.')
            raise exceptions.AuthenticationFailed(msg)

        try:
            user = User.objects.get_by_natural_key(username)
        except User.DoesNotExist:
            msg = _('Invalid signature.')
            raise exceptions.AuthenticationFailed(msg)

        if not user.is_active:
            msg = _('User account is disabled.')
            raise exceptions.AuthenticationFailed(msg)

        return user


class JSONWebTokenAuthentication(BaseJSONWebTokenAuthentication):
    """
    Clients should authenticate by passing the token key in the "Authorization"
    HTTP header, prepended with the string specified in the setting
    `JWT_AUTH_HEADER_PREFIX`. For example:

        Authorization: JWT eyJhbGciOiAiSFMyNTYiLCAidHlwIj
    """
    www_authenticate_realm = 'api'

    def get_jwt_value(self, request):
        
        auth = get_authorization_header(request).split()
        auth_header_prefix = api_settings.JWT_AUTH_HEADER_PREFIX.lower()

        if not auth:
            if api_settings.JWT_AUTH_COOKIE:
                return request.COOKIES.get(api_settings.JWT_AUTH_COOKIE)
            return None

        if smart_text(auth[0].lower()) != auth_header_prefix:
            return None
        
        # token如果不由 前缀JWT + 原token组成则抛出异常
        if len(auth) == 1:
            msg = _('Invalid Authorization header. No credentials provided.')
            raise exceptions.AuthenticationFailed(msg)
        elif len(auth) > 2:
            msg = _('Invalid Authorization header. Credentials string '
                    'should not contain spaces.')
            raise exceptions.AuthenticationFailed(msg)

        return auth[1]

    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.
        """
        return '{0} realm="{1}"'.format(api_settings.JWT_AUTH_HEADER_PREFIX, self.www_authenticate_realm)

通过了用户认证的类，request.user的对象要么是Anonymous或者是数据库中合法的user对象，至此，用户认证完毕。

三、权限认证

? 只有通过了用户认证的request请求才会进行权限认证。我们的某些接口通常需要vip用户才能访问，普通用户是无法进行访问的。但vip用户和普通用户都会通过用户认证，我们又该如何区分呢？

rest_framework文件夹下的permissions.py。

class BasePermission(metaclass=BasePermissionMetaclass):
    """
    A base class from which all permission classes should inherit.
    """

    def has_permission(self, request, view):
        """
        Return `True` if permission is granted, `False` otherwise.
        """
        return True

    def has_object_permission(self, request, view, obj):
        """
        Return `True` if permission is granted, `False` otherwise.
        """
        return True

'''
drf自带的权限认证类：
    - AllowAny 允许任何人
    - IsAuthenticated 只允许登录用户
    - IsAdminUser 只允许后台用户
    - IsAutenticatedOrReadOnly  只允许未登录用户读，允许登录用户读写

我们可以通过继承BasePermission类重写has_permission方法来实现自定义的权限认证类，认证通过返回True，否则返回False即可。
'''

校验用户是否是VIP或属于VIP分组的权限类 案例

class IsVipPermission(BasePermission):
    
    def has_permission(self, request, view):
        if request.user and request.user.is_authenticated and request.user.is_vip:
            return True
        else:
            return False

# 没有is_vip字段，有vip分组控制时
class IsVipPermission(BasePermission):
    
    def has_permission(self, request, view):
        vip_group = Group.objects.get(name='vip')
        if request.user and request.user.is_authenticated and (vip_group in request.user.groups.all()):
            return True
        else:
            return False

四、频率认证

? 当request请求通过用户认证和权限认证后，还要进行频率的检测，如果我们接口不限制访问频率，那么可能会让攻击者有机可乘，造成服务器的瘫痪。

rest_framework文件夹下的throttling.py中已经定义了基础的频率校验类。我们只需要继承SimpleRateThrottle类并重写get_cache_key方法。

案例：自定义频率类，只限制get请求的访问频率，不限制其他访问请求

class MethodRateThrottle(BaseThrottle):
   scope = 'method'  # scope
   def get_cache_key(self,request,view):
       if request.method.lower() == 'get':
       return self.cache_format % {
           'scope': self.scope,
           'ident': self.get_ident(request)
       }
       else:
           return None
'''
scope需要在settings.py中进行配置
get_cache_key方法，返回None代表 无限制访问，如果返回字符串，则该字符串会在缓冲中被保存（因为数据库中没有相应的表，所以我们推断内存中应该由一张虚拟的表，用来记录访问的频率）。
例如:限制了 3/min的访问频率，如果同一用户在1分钟内访问了3次，则会返回3次相同的字符串（因为该字符串是带有用户标识信息的get_indent，不同的用户的表示信息不同，一个用户被限制不会影响其他用户）。当第4次访问时，reqeust请求就会被拒绝。

'''

五、token刷新

drf-jwt为我们提供了token 的刷新功能，我们可以给token属性设置为可刷新。在token有效并且在刷新过期时间内，可以访问接口来刷新token的过期时间。

"""
1）运用在像12306这样极少数安全性要求高的网站
2）第一个token由登录签发
3）之后的所有正常逻辑，都需要发送两次请求，第一次是刷新token的请求，第二次是正常逻辑的请求
"""

settings.py

import datetime

JWT_AUTH = {
    # 配置过期时间
    'JWT_EXPIRATION_DELTA': datetime.timedelta(minutes=5),

    # 是否可刷新
    'JWT_ALLOW_REFRESH': True,
    # 刷新过期时间
    'JWT_REFRESH_EXPIRATION_DELTA': datetime.timedelta(days=7),
}

urls.py

from rest_framework_jwt.views import ObtainJSONWebToken, RefreshJSONWebToken
urlpatterns = [
    url('^login/$', ObtainJSONWebToken.as_view()),  # 登录签发token接口
    url('^refresh/$', RefreshJSONWebToken.as_view()),  # 刷新toekn接口
]

六、多方式登录

drf-jwt只为我们提供了 用户名-密码登录的签发token，是不支持用户以手机号、邮箱登录进行登录的。如果我们想实现多方式登录，必须自定义签发token。

serializers.py

class LoginSerializer(serializers.ModelSerializer):
    # 局部禁用
    authentication_classes = []
    permission_classes = []
    # 需要对字段进行覆盖，以免drf认为这是在做增数据自动校验
    username = serializers.CharField()
    password = serializers.CharField()
    class Meta:
        model = models.User
        fields = ['username', 'password']

    def validate(self, attrs):
        from rest_framework_jwt.serializers import jwt_payload_handler,jwt_encode_handler
        user = self._get_user(attrs)
        if user:
            payload = jwt_payload_handler(user)
            token = jwt_encode_handler(payload)
            self.context['token'] = token
            return attrs
        else:
            raise exceptions.ValidationError({"error":"username or password valid!"})

    def _get_user(self, attrs):
        import re
        username = attrs.get('username')  # type:str
        password = attrs.get('password')
        if re.match(r'^.+@.+$', username):
            # 邮箱登录
            print('..邮箱登录')
            user = models.User.objects.filter(email=username).first()
        elif re.match(r'^1[3-9][0-9]{9}$', username):
            print('..手机登录')
            user = models.User.objects.filter(mobile=username).first()
        else:
            user = models.User.objects.filter(username=username).first()
        if user and user.check_password(password):
            return user

urls.py

urlpatterns = [
    url('login/',views.LoginAPIViewSet.as_view({'post':"login"})),
]

views.py

class LoginAPIViewSet(viewsets.GenericViewSet):

    def login(self, request, *args, **kwargs):
        serializer = serializers.LoginSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        token = serializer.context.get('token')
        return Response({'token': token})

认证类的配置

'''
类的优先顺序:局部-->全局-->drf默认
'''
settings.py


JWT_AUTH = {
    # token存活时间
    'JWT_EXPIRATION_DELTA': datetime.timedelta(seconds=300),
    # token前缀
    'JWT_AUTH_HEADER_PREFIX': 'JWT',
}

REST_FRAMEWORK = {
    # 用户认证
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework_jwt.authentication.JSONWebTokenAuthentication',
    ],
    # 权限认证
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.AllowAny',
    ],
    # 频率认证
    'DEFAULT_THROTTLE_CLASSES': [],
  
    # 频率配置
    'DEFAULT_THROTTLE_RATES': {
        'user': '3/min', # duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        'anon': None,
    },
}