[Django REST framework - JWT认证、token刷新机制、多方式登录]

[Django REST framework - JWT认证、token刷新机制、多方式登录]

JWT认证

官网：https://github.com/jpadilla/django-rest-framework-jwt

在用户注册或登录后，我们想记录用户的登录状态，或者为用户创建身份认证的凭证。我们不再使用Session认证机制，而使用Json Web Token（本质就是token）认证机制.

jwt：json web token，前后端的认证方式，有三段：头，荷载，签名，区别于session，不需要在服务端存储信息，还能保证认证的安全

Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。

jwt优势

1）没有数据库写操作，高效

2）服务器不存token，低耗

3）签发校验都是算法，集群

jwt认证算法：签发与校验

"""
1）jwt分三段式：头.体.签名 （head.payload.sgin）

2）头和体是可逆加密，让服务器可以反解出user对象；签名是不可逆加密，保证整个token的安全性的

3）头体签名三部分，都是采用json格式的字符串，进行加密，可逆加密一般采用base64算法，不可逆加密一般采用hash(md5)算法

4）头中的内容是基本信息：公司信息、项目组信息、token采用的加密方式信息
{
	"company": "公司信息",
	...
}
5）体中的内容是关键信息：用户主键、用户名、签发时客户端信息(设备号、地址)、过期时间
{
	"user_id": 1,
	...
}
6）签名中的内容时安全信息：头的加密结果 + 体的加密结果 + 服务器不对外公开的安全码 进行md5加密
{
	"head": "头的加密字符串",
	"payload": "体的加密字符串",
	"secret_key": "安全码"
}
"""

签发：根据登录请求提交来的 账号 + 密码 + 设备信息 签发 token

"""
1）用基本信息存储json字典，采用base64算法加密得到 头字符串

2）用关键信息存储json字典，采用base64算法加密得到 体字符串

3）用头、体加密字符串再加安全码信息存储json字典，采用hash md5算法加密得到 签名字符串


账号密码就能根据User表得到user对象，形成的三段字符串用 . 拼接成token返回给前台
"""

校验：根据客户端带token的请求 反解出 user 对象

"""

1）将token按 . 拆分为三段字符串，第一段 头加密字符串 一般不需要做任何处理

2）第二段 体加密字符串，要反解出用户主键，通过主键从User表中就能得到登录用户，过期时间和设备信息都是安全信息，确保token没过期，且时同一设备来的

3）再用 第一段 + 第二段 + 服务器安全码 不可逆md5加密，与第三段 签名字符串 进行碰撞校验，通过后才能代表第二段校验得到的user对象就是合法的登录用户

"""

drf项目的jwt认证开发流程

"""
1）用账号密码访问登录接口，登录接口逻辑中调用 签发token 算法，得到token，返回给客户端，客户端自己存到cookies中

2）校验token的算法应该写在认证类中(在认证类中调用)，全局配置给认证组件，所有视图类请求，都会进行认证校验，所以请求带了token，就会反解出user对象，在视图类中用request.user就能访问登录的用户

注：登录接口需要做 认证 + 权限 两个局部禁用
"""

drf-jwt框架基本使用

安装（终端）

>: pip install djangorestframework-jwt

签发token(登录接口)：视图类已经写好了，配置一下路由就行（urls.py）

# urls.py
urlpatterns = [
    # ...
    url('^login/$', ObtainJSONWebToken.as_view()),
]

# Postman请求：/login/，提供username和password即可

校验token(认证组件)：认证类已经写好了，全局配置一下认证组件就行了（settings.py）

# drf-jwt的配置
import datetime
JWT_AUTH = {
    # 配置过期时间
    'JWT_EXPIRATION_DELTA': datetime.timedelta(days=7),
}


# drf配置（把配置放在最下方）
REST_FRAMEWORK = {
    # 自定义三大认证配置类们
    'DEFAULT_AUTHENTICATION_CLASSES': ['rest_framework_jwt.authentication.JSONWebTokenAuthentication'],
    # 'DEFAULT_PERMISSION_CLASSES': [],
    # 'DEFAULT_THROTTLE_CLASSES': [],
}

设置需要登录才能访问的接口进行测试（views.py）

from rest_framework.permissions import IsAuthenticated
class UserCenterViewSet(GenericViewSet, mixins.RetrieveModelMixin):
    # 也可局部配置认证
    authentication_classes = [JSONWebTokenAuthentication]
    # 设置必须登录才能访问的权限类
    permission_classes = [IsAuthenticated, ]

    queryset = models.User.objects.filter(is_active=True).all()
    serializer_class = serializers.UserCenterSerializer

测试访问登录认证接口（Postman）

"""
1）用 {"username": "你的用户", "password": "你的密码"} 访问/login/ 接口等到 token 字符串

2）在请求头用 Authorization 携带 "jwt 登录得到的token" 访问 /book/ 接口访问个人中心
"""

token刷新机制（了解）

drf-jwt直接提供刷新功能

"""
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接口
]

Postman

# 接口：/refresh/
# 方法：post
# 数据：{"token": "登录签发的token"}

基于jwt的认证类(重写认证类)

1 重点逻辑authenticate方法中
	-取出客户端传入的token（后端自己规定，写道接口文档中过了），请求头中，请求地址。。。
    -验证jwt的签名（模块提供了）
    -通过payload得到当前登录用户对象（模块提供了）
    -return user,token

from rest_framework.exceptions import AuthenticationFailed
from rest_framework_jwt.settings import api_settings
import jwt
# from rest_framework_jwt.utils import jwt_decode_handler
jwt_decode_handler = api_settings.JWT_DECODE_HANDLER
jwt_get_username_from_payload = api_settings.JWT_PAYLOAD_GET_USERNAME_HANDLER
from rest_framework_jwt.authentication import BaseJSONWebTokenAuthentication
from django.contrib.auth.models import User
# BaseJSONWebTokenAuthentication
class JWTAuthentication(BaseJSONWebTokenAuthentication):
    # def authenticate_credentials(self, payload):
    #     username = jwt_get_username_from_payload(payload)
    #     if not username:
    #         raise AuthenticationFailed()
    #     try:
    #         user = User.objects.get_by_natural_key(username)
    #     except User.DoesNotExist:
    #         msg = 'Invalid signature.'
    #         raise AuthenticationFailed(msg)
    #
    #     if not user.is_active:
    #         msg ='User account is disabled.'
    #         raise AuthenticationFailed(msg)
    #     return user
    def authenticate(self, request):
        print(request.META)
        # token=request.query_params.get('HTTP_AUTHORIZATION',None)
        token=request.META.get('HTTP_AUTHORIZATION',None)
        if token:
            # 校验token是不是过期了，是不是合法，
            try:
                payload = jwt_decode_handler(token)
                print(payload)
            except jwt.ExpiredSignature:

                raise AuthenticationFailed('token过期')
            except jwt.DecodeError:

                raise AuthenticationFailed('token认证失败')
            except jwt.InvalidTokenError:
                raise AuthenticationFailed('token不合法')
        else:
           raise AuthenticationFailed('token没有携带')

        '''
        # 三种方案得到user
            -继承BaseJSONWebTokenAuthentication，self.authenticate_credentials
            -直接把BaseJSONWebTokenAuthentication，authenticate_credentials方法拿出来，放到自己类中
            -完全自己写

        '''

        user = self.authenticate_credentials(payload)

        return (user, token)

3 基于自定义User表，签发token（5星）

3.2 路由

from rest_framework.routers import DefaultRouter,SimpleRouter
router=SimpleRouter()
router.register('books',views.BookView)
router.register('user',views.UserInfoView,basename='user')
urlpatterns = [
    path('', include(router.urls)),
]

3.2 视图类

from rest_framework.viewsets import ViewSet
from rest_framework.decorators import action
from rest_framework.response import Response
from .models import User
from rest_framework_jwt.settings import api_settings
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
class UserInfoView(ViewSet):
    @action(methods=['POST'],detail=False)
    def login(self,request):
        username=request.data.get('username')
        password=request.data.get('password')
        res={'code':'100','msg':'登录成功'}
        user=User.objects.filter(username=username,password=password).first()
        if user:
            # 登录成功,生成token，提供了（去找）
            payload = jwt_payload_handler(user)
            token=jwt_encode_handler(payload)
            res['token']=token

        else:
            res['code']=101
            res['msg']='用户名或密码错误'
        return Response(res)

3.3 认证类

from .models import User
class JWTMyUserAuthentication(BaseAuthentication):
    def authenticate(self, request):
        token=request.META.get('HTTP_AUTHORIZATION',None)
        if token:
            try:
                payload = jwt_decode_handler(token)
                print(payload)
            except jwt.ExpiredSignature:

                raise AuthenticationFailed('token过期')
            except jwt.DecodeError:

                raise AuthenticationFailed('token认证失败')
            except jwt.InvalidTokenError:
                raise AuthenticationFailed('token不合法')
        else:
           raise AuthenticationFailed('token没有携带')

        user=User.objects.get(pk=payload.get('user_id'))
        # user=User(id=payload.get('user_id'),username=payload.get('username'))
        # 优化，减少数据库压力（）
        # user={'id':payload.get('user_id'),'username':payload.get('username')}
        return (user, token)

3.4 Book接口

from .auth import JWTMyUserAuthentication

class BookView(ViewSetMixin,ListAPIView,CreateAPIView):
    queryset = Books.objects.all()
    serializer_class = BookSerializer
    authentication_classes = [JWTMyUserAuthentication,]


    def list(self, request, *args, **kwargs):
        print(request.user['id'])
        return super().list(request, *args, **kwargs)

4 多方式登录（重点）

1 使用用户名，邮箱，手机号+密码都能登录成功
2 可以使用auth 的user表，也可以自定义用户表
3 扩写auth的user表，要么不用，要用一定要在项目开始就使用（没有迁移之前）
4 如果已经迁移了（正常是不能再使用了），如果还想用，解决方案：
	-删库
    -删除迁移记录（app的迁移记录，auth app的迁移记录（源码中），admin app的迁移记录（源码中））

4.1 视图类

from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.viewsets import ViewSet
from .serizlizer import UserSerializer


class UserInfoView(ViewSet):
     # 登录接口，要取消所有的认证与权限规则，也就是要做局部禁用操作（空配置）
    authentication_classes = []
    permission_classes = []
    
    # 需要和mixins结合使用，继承GenericViewSet，不需要则继承ViewSet
    # 为什么继承视图集，不去继承工具视图或视图基类，因为视图集可以自定义路由映射：
    #       可以做到get映射get，get映射list，还可以做到自定义（灵活）
    @action(methods=['POST'], detail=False)
    def login(self, request):
        # 把认证逻辑和签发token逻辑，放到序列化类中写
        res = {'code': 100, 'msg': '登录成功', 'token': None}
        # ser=UserSerializer(data=request.data,context={'request':request})
        ser = UserSerializer(data=request.data)
        if ser.is_valid():
            # 拿到存放到context中的 token返回
            res['token'] = ser.context['token']

        else:
            res['code'] = 101
            res['msg'] = ser.errors
        return Response(res)

4.2 序列化类

from .models import User
import re
from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from rest_framework_jwt.settings import api_settings
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
class UserSerializer(serializers.ModelSerializer):
        # 登录请求，走的是post方法，默认post方法完成的是create入库校验，所以唯一约束的字段，会进行数据库唯一校验，导致逻辑相悖
    # 需要覆盖系统字段，自定义校验规则，就可以避免完成多余的不必要校验，如唯一字段校验
    
    username=serializers.CharField()  # 一定要重写username字段
    class Meta:
        model=User
           # 结合前台登录布局：采用账号密码登录，或手机密码登录，布局一致，所以不管账号还是手机号，都用username字段提交的
        fields=['username','password']

	
    def validate(self, attrs):
		# 1、在全局钩子中，才能提供提供的所需数据，整体校验得到user        
        user=self._get_user(attrs) # 4、拿到返回值user

        # 5、签发token 调用方法执行
        token=self._get_token(user)
		
        # 8、将token存放到context属性中，传给外键视图类使用
        self.context['token']=token
		
        return attrs

    def _get_user(self,attrs):  # 2、执行此方法
        username = attrs.get('username')# username:可能是手机号，可能是邮箱，可能是用户名
        password = attrs.get('password')
        # 使用正则去匹配，手机号，邮箱或者其他
        if re.match(r'^1[3-9][0-9]{9}$', username):
            user=User.objects.filter(phone=username).first()
        elif re.match(r'^.+@.+$', username):
            user = User.objects.filter(email=username).first()
        else:
            user = User.objects.filter(username=username).first()
        if user:
            if user.check_password(password):

                return user  # 3、返回user
            else:
                raise ValidationError('密码错误')
        else:
            raise ValidationError('用户不存在')

    def _get_token(self,user):
        # 6、再就可以调用签发token算法(drf-jwt框架提供的)，将user信息转换为token
        payload = jwt_payload_handler(user)
        token=jwt_encode_handler(payload)
        
        return token  # 7、返回token