drf三大认证解析

三大认证

认证模块：

self.perform_authentication(request)

校验用户是否登录

三种状态： 登录用户，非法用户，游客、

1. 登录用户：合法的后台用户
2. 非法用户：无法正常访问，访问被拒绝
3. 游客：只能访问部分信息

权限模块

self.check_permissions(request)

校验用户是否拥有权限，校验对象是登录用户和游客

频率模块

self.check_throttles(request)

访问接口的次数在设定的时间范围内是否过快，配置访问频率，每次访问都要缓存记次，超次后需要等待的时间。

RABC

基于校色权限访问控制方式

author组件 认证权限六表、

Content_type

# 给Django中的所有模块中的所有表进行编号存储到content_type表中
# 应用一：权限表的权限是操作表的，所有在权限表中有一个content_type表的外键，标识该权限具体操作的是哪张表
# 应用二：价格策略

"""
Course：
name、type、days、price、vip_type
基础  免费课  7      0
中级  学位课  180    69
究极  会员课  360         至尊会员


Course：
name、type、days、content_type_id
基础  免费课  7    null
中级  学位课  180   1
究极  会员课  360   2

app01_course_1
id、price

app01_course_2
id vip_type

content_type表（Django提供）
id、app_label、model
1   app01    course_1
2   app01    course_2
"""

认证与权限工作原理+自定义认证类

项目》utils》authentications

# 自定义认证类

"""
认证模块工作原理
1）继承BaseAuthentication类，重写authenticate方法
2）认证规则(authenticate方法实现体)：
    没有携带认证信息，直接返回None => 游客
    有认证信息，校验失败，抛异常 => 非法用户
    有认证信息，校验出User对象 => 合法用户
"""

from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
class TokenAuthentication(BaseAuthentication):
  prefix = 'Token'
  def authenticate(self, request):
    # 拿到前台的token
    auth = request.META.get('HTTP_AUTHORIZATION')
    # 没有返回None，有进行校验
    if not auth:
      return None
    auth_list = auth.split()

    if not (len(auth_list) == 2 and auth_list[0].lower() == self.prefix.lower()):
      raise AuthenticationFailed('非法用户')

      token = auth_list[1]

      # 校验算法
      user = _get_obj(token)
      # 校验失败抛异常，成功返回（user, token）
      return (user, token)

    # 校验算法（认证类）与签发算法配套
"""
拆封token：一段 二段 三段
用户名：b64decode(一段)
用户主键：b64decode(二段)
碰撞解密：md5(用户名+用户主键+服务器秘钥) == 三段
"""
    import base64, json, hashlib
    from django.conf import settings
    from api.models import User
    def _get_obj(token):
      token_list = token.split('.')
      if len(token_list) != 3:
        raise AuthenticationFailed('token异常')
        username = json.loads(base64.b64decode(token_list[0])).get('username')
        pk = json.loads(base64.b64decode(token_list[1])).get('pk')

        md5_dic = {
          'username': username,
          'pk': pk,
          'key': settings.SECRET_KEY
        }

        if token_list[2] != hashlib.md5(json.dumps(md5_dic).encode()).hexdigest():
          raise AuthenticationFailed('token内容异常')

          user_obj = User.objects.get(pk=pk, username=username)
          return user_obj


""" 认证类的认证核心规则
def authenticate(self, request):
    token = get_token(request)
    try:
        user = get_user(token)  # 校验算法
    except:
        raise AuthenticationFailed()
    return (user, token)
"""

自定义权限类

项目》utils》permissions

# 自定义权限类

"""
权限模块工作原理
1）继承BasePermission类，重写has_permission方法
2）权限规则(has_permission方法实现体)：
    返回True，代表有权限
    返回False，代表无权限
"""
from rest_framework.permissions import BasePermission
class SuperUserPermission(BasePermission):
    def has_permission(self, request, view):
        # print(request.user)
        # print(request.auth)

        return request.user and request.user.is_superuser

admin关联自定义用户表

from django.contrib import admin

from . import models

# admin注册自定义User表：密文操作密码
from django.contrib.auth.admin import UserAdmin as AuthUserAdmin
class UserAdmin(AuthUserAdmin):
  add_fieldsets = (
    (None, {
      'classes': ('wide',),
      # 添加用户界面可操作的字段
      'fields': ('username', 'password1', 'password2', 'mobile', 'email', 'is_staff', 'is_active'),
    }),
  )
  list_display = ('username', 'mobile', 'email', 'is_staff', 'is_active')

  # 明文操作密码，admin可视化添加的用户密码都是明文，登录时用的是密文，所以用户无法登录
  # admin.site.register(models.User)
  admin.site.register(models.User, UserAdmin)

项目》api》views.py

from rest_framework.views import APIView
from utils.response import APIResponse
class TestAPIView(APIView):
  def get(self, request, *args, **kwargs):
    print(request.user)  # AnonymousUser - 游客
    return APIResponse()



  # 了解 - 自定义认证与权限类 - 实际开发，系统和第三方提供的认证与权限类已经够用了，特别特殊的需求才需要自定义
  """
自定义认证类、权限类

准备数据：
"""

  from rest_framework.generics import ListAPIView
  from . import models, serializers
  # 查看所有用户信息，前提：必须是登录的超级管理员
  from utils.authentications import TokenAuthentication
  from utils.permissions import SuperUserPermission
  class UserListAPIView(ListAPIView):
    # 同电商网站，多接口是不需要登录的，少接口需要登录，使用在需要登录的接口中完成局部配置，进行局部接口校验
    authentication_classes = [TokenAuthentication]
    permission_classes = [SuperUserPermission]

    queryset = models.User.objects.filter(is_active=True, is_superuser=False).all()
    serializer_class = serializers.UserModelSerializer

    def get(self, request, *args, **kwargs):
      response = self.list(request, *args, **kwargs)
      return APIResponse(data=response.data)


    # 登录接口：如果是超级管理员登录，返回一个可以交易出超级管理员的token字符串
    # 只要有用户登录，就可以返回一个与登录用户相关的token字符串 => 返回给前台 => 签发token => user_obj -> token_str

    from rest_framework.generics import GenericAPIView
    class LoginAPIView(APIView):
      # 登录接口一定要做：局部禁用 认证 与 权限 校验
      authentication_classes = []
      permission_classes = []
      def post(self, request, *args, **kwargs):
        serializer = serializers.LoginModelSerializer(data=request.data)
        # 重点：校验成功后，就可以返回信息，一定不能调用save方法，因为该post方法只完成数据库查操作
        # 所以校验会得到user对象，并且在校验过程中，会完成token签发（user_obj -> token_str）
        serializer.is_valid(raise_exception=True)
        return APIResponse(data={
          'username': serializer.user.username,
          'token': serializer.token
        })

前后台分离登录接口+自定义签发token算法（第三方）

serializers.py

from rest_framework import serializers
from rest_framework.serializers import ModelSerializer, ValidationError
from . import models
class UserModelSerializer(ModelSerializer):
  class Meta:
    model = models.User
    fields = ('username', 'email', 'mobile')



    from django.contrib.auth import authenticate
    class LoginModelSerializer(ModelSerializer):
      # username和password字段默认会走系统校验，而系统的post请求校验，一定当做增方式校验，所以用户名会出现 重复 的异常
      # 所以自定义两个字段接收前台的账号密码
      usr = serializers.CharField(write_only=True)
      pwd = serializers.CharField(write_only=True)
      class Meta:
        model = models.User
        fields = ('usr', 'pwd')
        def validate(self, attrs):
          usr = attrs.get('usr')
          pwd = attrs.get('pwd')
          try:
            user_obj = authenticate(username=usr, password=pwd)
            except:
              raise ValidationError({'user': '提供的用户信息有误'})

              # 拓展名称空间
              self.user = user_obj
              # 签发token
              self.token = _get_token(user_obj)

              return attrs


            # 自定义签发token
            # 分析：拿user得到token，后期还需要通过token得到user
            # token：用户名(base64加密).用户主键(base64加密).用户名+用户主键+服务器秘钥(md5加密)
            # eg: YWJj.Ao12bd.2c953ca5144a6c0a187a264ef08e1af1

            # 签发算法：b64encode(用户名).b64encode(用户主键).md5(用户名+用户主键+服务器秘钥)
            # 校验算法（认证类）与签发算法配套
"""
拆封token：一段 二段 三段
用户名：b64decode(一段)
用户主键：b64decode(二段)
碰撞解密：md5(用户名+用户主键+服务器秘钥) == 三段
"""
            def _get_token(obj):
              import base64, json, hashlib
              from django.conf import settings
              t1 = base64.b64encode(json.dumps({'username': obj.username}).encode()).decode()
              t2 = base64.b64encode(json.dumps({'pk': obj.id}).encode()).decode()
              t3_json = json.dumps({
                'username': obj.username,
                'pk': obj.id,
                'key': settings.SECRET_KEY
              })
              t3 = hashlib.md5(t3_json.encode()).hexdigest()
              return '%s.%s.%s' % (t1, t2, t3)

可逆的加密解密

注意： 使用时间戳以后会变成不可逆

t-py

# 可逆的加密解密
import base64
s = 'abc'

# 加密
s1 = base64.b64encode(s.encode())
print(s1)

# 解密
s2 = base64.b64decode(s1).decode()
print(s2)

import hashlib

# 盐
SECRET_KEY = 'm#mh1=hyrj=wgqgz)x%@!c9^jg%@sv9iqcsrh7k-*#1u)jg0un'

# 加密
s3 = hashlib.md5(s.encode())
s3.update(SECRET_KEY.encode())
print(s3.hexdigest())

n_s = 'abc'
n_s3 = hashlib.md5(n_s.encode())
n_s3.update(SECRET_KEY.encode())

print(s3.hexdigest() == n_s3.hexdigest())