35 JWT 认证

898次阅读

没有评论

共计 12325 个字符，预计需要花费 31 分钟才能阅读完成。

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

35 JWT 认证

服务器需要存储用户的 token 信息

35 JWT 认证

服务端不需要存储用户 token, 都存在客户端

JWT 就是一段字符串, 由三段信息构成, 三段信息文本使用.(点) 拼接就构成了 JWT 字符串 :

eyJhbGciOiJIUzI1sNiIsIn.eyJzdWIiOiIxMjRG9OnRydWV9.TJVArHDcEfxjoYZgeFONFh7HgQ
第一部分我们称它为头部 : header
第二部分我们称其为载荷 : payload (类似于飞机上承载的物品)
第三部分是签证 : signature

两部分组成 :

声明类型(当前令牌名称)
声明加密算法

{
  'typ': 'JWT',
  'alg': 'HS256'
}

将头部使用 base64 编码构成第一部分 (下面介绍 base64 编码方法, 该编码可以对称解码)

eyJ0eXAiOiJKV1iIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiQiLCJhbGciO

存放用户有效信息的地方, JWT 规定了 7 个官方字段, 可以选用

iss (issuer)：签发人
exp (expiration time)：过期时间
sub (subject)：主题
aud (audience)：受众
nbf (Not Before)：生效时间
iat (Issued At)：签发时间
jti (JWT ID)：编号

除了上面的字段, 你自己也可以添加自己想要的字段, 需要注意的是: 这些信息是不加密的, 所以最好不要存敏感信息

{
  "sub": "1234567890",
  "name": "John Doe",
  "age": 23
  "admin": true
}

将载荷使用 base64 编码构成第二部分

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9

signature 由三部分构成 :

base64 编码后的 header
base64 编码后的 payload
secret : 秘钥 (只有服务端知道)

# 使用 header 中指定的加密算法将三个信息以下面的方式进行加密
string = [base64 编码后的 header] + "." + [base64 编码后的 payload]  # 字符串拼接
HMACSHA256(string, secret)  # 加密算法加密得到加密摘要(TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONF)

算出签名之后, 把 header、payload、signatrue 三部分使用 .(点) 拼接成一个大字符串, 然后返回给客户端让其存储

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

注意 :

secret 是保存在服务器端的, jwt 的签发生成也是在服务器端的

secret 就是用来进行 jwt 的签发和 jwt 的验证, 所以, 它就是你服务端的私钥

在任何场景都不应该流露出去, 一旦客户端得知这个 secret, 那就意味着客户端是可以自我签发 jwt 了

首先 base64 是一种编码方式, 并非加密方式; 它跟语言无关, 任何语言都能使用 base64 编码 & 解码

import base64
import json

# 定义一个信息字段
dic = {"id": 1, "name": "shawn", "age": "male"}

# 将其序列化成 json 格式字符串
json_str = json.dumps(dic)

# 将 json 格式字符串 encode 再使用 base64 编码成一串 Bytes 格式编码
base64_bytes = base64.b64encode(json_str.encode('utf-8'))

print(base64_bytes)  
# b'eyJpZCI6IDEsICJuYW1lIjogInNoYXduIiwgImFnZSI6ICJtYWxlIn0='
print(base64_bytes.decode('utf-8'))  
# eyJpZCI6IDEsICJuYW1lIjogInNoYXduIiwgImFnZSI6ICJtYWxlIn0=

得到的字符串后面有等号, 代表不是 4 的倍数使用等号填充

import base64
import json

bytes_str = b'eyJpZCI6IDEsICJuYW1lIjogInNoYXduIiwgImFnZSI6ICJtYWxlIn0='
res = base64.b64decode(bytes_str)

print(res)  # b'{"id": 1, "name": "shawn", "age": "male"}'

JWT 的本质原理就是签发和校验 : 关于签发和核验 JWT, 我们可以使用 Django REST framework JWT 扩展来完成

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

用基本信息存储 json 字典, 采用 base64 编码得到 头字符串
用关键信息存储 json 字典，采用 base64 编码得到 体字符串
用头、体编码的字符串再加安全码信息 (secret) 存储 json 字典, 采用 header 中指定的算法加密得到 签名字符串

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

将 token 按 .(点) 拆分为三段字符串, 第一段编码后的 头字符串 一般不需要做任何处理
第二段编码后的 体字符串, 要解码出用户主键, 通过主键从 User 表中就能得到登录用户, 过期时间和设备信息都是安全信息, 确保 token 没过期, 且是同一设备来的
再将 第一段 + 第二段 + 服务器安全码 使用 header 中指定的不可逆算法加密, 与第三段 签名字符串 进行对比校验, 通过后才能代表第二段校验得到的 user 对象就是合法的登录用户

用账号密码访问登录接口, 登录接口逻辑中调用签发 token 算法, 得到 token, 返回给客户端, 客户端自己存到 cookies 中 (上面有流程图介绍)
校验 token 的算法应该写在认证类中(在认证类中调用), 全局配置给认证组件, 所有视图类请求, 都会进行认证校验, 所以请求带了 token, 就会反解出 user 对象, 在视图类中用 request.user 就能访问登录的用户

ps : 登录接口需要做 认证 + 权限 两个局部禁用

JWT 的本质原理就是签发和校验 : 关于签发和核验 JWT, 我们可以使用 Django REST framework JWT 扩展来完成

👉GitHub : https://github.com/jpadilla/django-rest-framework-jwt

pip install djangorestframework-jwt

简单使用 : 自动签发 token 和自动认证

# 默认使用的是 auth 的 user 表
# 不需要书写登入功能以及认证类, jwt 都内置了

先在 auth_user 中创建一个用户

# 终端
manage.py@jwt_test > createsuperuser
用户名 : ...
邮箱 : 直接回车跳过
密码: ...
确认密码: ...

urls.py

from django.contrib import admin
from django.urls import path
from rest_framework_jwt.views import obtain_jwt_token  # 就是一个视图函数

urlpatterns = [path('admin/', admin.site.urls),
    path('login/', obtain_jwt_token),  # jwt 提供的认证
]

Postman 中进行测试

35 JWT 认证

提交数据, jwt 认证进行校验并签发 token, 返回客户端

obtain_jwt_token 的本质, 我们可以 Ctrl+ 点击进入源码查看

35 JWT 认证

# 所以说它本质就是一个视图类, 我们也可以这样填写👇
path('login/', ObtainJSONWebToken.as_view()),

# djangorestframework-jwt 也有配置文件，也有默认配置
# 默认过期时间是 5 分钟 (可以进行配置)

# settings.py 文件
import datatime

JWT_AUTH = {
    # 自定义过期时间 1 天
    'JWT_EXPIRATION_DELTA': datetime.timedelta(days=1),
    # 也可以自定义认证结果 reaponse (下面介绍)
    # 如果不自定义, 返回的格式是固定的, 只有 token 字段(如上面演示所看到的)
    'JWT_RESPONSE_PAYLOAD_HANDLER': 'users.utils.custom_jwt_response_payload_handler',  
}

使用 jwt 内置登入认证, 但自定义 response 内的信息
限制查询图书接口必须登录才能用 (加在视图类中)

我们可以先查看默认的 jwt 响应

# 导入 jwt 响应, Ctrl+ 点击 进入源码查看
from rest_framework_jwt.utils import jwt_response_payload_handler

35 JWT 认证

我们直接 copy 过来修改

myresponse.py

# 重写该响应
def custom_jwt_response_payload_handler(token, user=None, request=None):
    return {
        'status': 200,
        'messages': 'success!',
        'user_id': user.id,
        'username': user.username,
        'token': token
    }

settings.py

import datatime

JWT_AUTH = {
    # 自定义过期时间 7 天
    'JWT_EXPIRATION_DELTA': datetime.timedelta(days=7),
    # 指定自己重写的 jwt 响应
    'JWT_RESPONSE_PAYLOAD_HANDLER': 'drf_test.myresponse.custom_jwt_response_payload_handler',
}

models.py

# 创建建书籍表, 并自行添加书籍
from django.db import models

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.IntegerField()

serializer.py

from rest_framework import serializers
from drf_test import models

# 创建一个书籍的序列化类
class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Book
        fields = "__all__"
        extra_kwargs = {
            'title': {'help_text': '这是书籍的名字!!'}
        }

views.py

from drf_test import serializer
from drf_test import models
from rest_framework.viewsets import ModelViewSet
from rest_framework_jwt.authentication import JSONWebTokenAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.pagination import PageNumberPagination
PageNumberPagination.page_size = 2  # 设置分页的单页显示条数


class BookView(ModelViewSet):
    queryset = models.Book.objects.all()
    serializer_class = serializer.BookModelSerializer
    pagination_class = PageNumberPagination

    # 如果使用 jwt 内置的认证类, 需要配合一个权限类
    # 因为只加认证类, 只要带了 token, 就认证, 不带 token 就不认证
    # 所以就算你不带 token 也可以查到书籍, 这不是我们想要的效果
    authentication_classes = [JSONWebTokenAuthentication,]
    # 判断当前登录用户是否通过了认证(需要配合这个权限类)
    permission_classes = [IsAuthenticated,]

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

自定义响应测试

35 JWT 认证

测试认证通过后能访问书籍, 不通过无法访问

35 JWT 认证

上面测试注意事项 : token 放在 Headers 中, 并且 Key 为 Authorization (源码里规定这么写的)

35 JWT 认证

使用 jwt 内置的认证, 如果没有修改配置文件中配置的前缀, 那么 jwt前缀 (大小写都行) 必须要加, 如果不加前缀认证就返回 None, 认证就失效了

# 格式
Authorization:JWT [三段式的 token]  # jwt + 空格 + token, 源码里是以空格切分

35 JWT 认证

也可以修改认证前缀

JWT_AUTH = {
'JWT_RESPONSE_PAYLOAD_HANDLER': 'drf_test.myresponse.custom_jwt_response_payload_handler',
'JWT_AUTH_HEADER_PREFIX': 'MYJWT',  # 了解一下就行, 一般不改
}

上面的实战例子我们使用的是 jwt 自带的认证类, 如果我们要自己手动写, 就必须重写 authenticate 方法, 我们看看其源码的逻辑:

35 JWT 认证

自建一个 auth 认证类文件书写

import jwt
from drf_test import models
from rest_framework import exceptions
from rest_framework_jwt.authentication import JSONWebTokenAuthentication
from rest_framework_jwt.settings import api_settings

jwt_decode_handler = api_settings.JWT_DECODE_HANDLER
'''JWT_DECODE_HANDLER 在源码中所对应的方法:'rest_framework_jwt.utils.jwt_decode_handler'将该方法内存地址赋值给:jwt_decode_handler'''

# 继承 JSONWebTokenAuthentication 类来书写
class CustomJsonAuthentication(JSONWebTokenAuthentication):
    # 认证类必须重写 authenticate 方法
    def authenticate(self, request):
        # 1. 获取到 request 中的 token
        jwt_value = self.get_jwt_value(request)
        # 2. 也可以直接将 token 放在 url 中使用 get 来获取(但一般不这么做)
        # jwt_value = self.request.GET.get('token')
        # 3. 还可以从 META 中获取
        # jwt_value = request.META.get('HTTP_AUTHORIZATION')
        if jwt_value:
            # 验证签名
            try:
                # 得到荷载
                payload = jwt_decode_handler(jwt_value)
                # 直接从数据库中找出用户对象(每次都要查询数据库, 消耗大, 并且并不是所有字段都需要)
                # user_obj = models.User.objects.filter(id=payload['user_id']).first()
                # 可以临时生成一个只有 id 和 username 的对象, 只有需要的时候才拿出 id 或 username 去数据库中过滤用户
                user_obj = models.User(id=payload['user_id'],username=payload['username'])
                # 又或者直接使用字典的方式(能取出值就 ok)
                # user_obj = {'id':payload['user_id'],'username':payload['username']}

            except jwt.ExpiredSignature:
                raise exceptions.AuthenticationFailed('token 已过期')
            except jwt.DecodeError:
                raise exceptions.AuthenticationFailed('签名错误')
            except jwt.InvalidTokenError as e:
                raise exceptions.AuthenticationFailed(e)
            return user_obj,jwt_value
        raise exceptions.AuthenticationFailed('请携带 token 进行认证!')

views.py

from drf_test import serializer
from drf_test import models
from rest_framework.viewsets import ModelViewSet
from rest_framework.pagination import PageNumberPagination
PageNumberPagination.page_size = 2

# 导入自定义的认证类
from drf_test.auth.customauth import CustomJsonAuthentication

class BookView(ModelViewSet):
    queryset = models.Book.objects.all()
    serializer_class = serializer.BookModelSerializer
    pagination_class = PageNumberPagination

    # 自己写的认证类
    authentication_classes = [CustomJsonAuthentication,]

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

不携带 token

35 JWT 认证

提供错误的 token

35 JWT 认证

验证通过

35 JWT 认证

如果我们要实现自定义的 token 签发就必须了解 jwt token 签发的原理
前面我们自定义响应格式的时候返回了一个 token, 这里已经有 token, 那么 token 是在哪里产生的呢?
我们猜想应该是 request 传进来到序列化类进行校验, 校验成功后就签发 token 的
查看 jwt 的序列化类

35 JWT 认证

jwt_payload_handler 源码分析

# 导入该方法 Ctrl + 点击 进入
from rest_framework_jwt.utils import jwt_payload_handler

35 JWT 认证

jwt_encode_handler 源码分析

35 JWT 认证

将 auth_user 表该个名, 自己新建个 User 表方便实验 (models.py)

from django.db import models
from django.contrib.auth.models import AbstractUser


class UserInfo(AbstractUser):
    phone = models.BigIntegerField(null=True)


class User(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)

存入用户名和密码

views.py

from rest_framework.response import Response
from rest_framework.views import APIView
# 导入 jwt 配置文件
from rest_framework_jwt.settings import api_settings

# 将获取 payload 的方法以及签发 token 的方法内存地址赋值给两个变量
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER


class UserLoginView(APIView):
    def post(self, request, *args, **kwargs):
        username = request.data.get('username')
        password = request.data.get('password')

        user = models.User.objects.filter(username=username, password=password).first()
        if user:
            # 调用两个方法签发 token
            payload = jwt_payload_handler(user)
            token = jwt_encode_handler(payload)
            return Response({'status': 200, 'msg': '登入成功!', 'token': token})
        else:
            return Response({'status': 201, 'msg': '用户名或密码错误!'})

urls.py

path('login2/', views.UserLoginView.as_view()),

用户名或密码错误测试

35 JWT 认证

登入成功测试

35 JWT 认证

登入方式多种 : (用户名、输入手机号、输入邮箱) + 密码
逻辑书写在序列化类中

serializer.py

from django.db.models import Q  # 用来构建或与非
from rest_framework.exceptions import ValidationError
# 导入 jwt 配置文件
from rest_framework_jwt.settings import api_settings
# 将获取 payload 的方法以及签发 token 的方法内存地址赋值给两个变量
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER


# 多登入方式序列化类
class VariousLoginModelSerializer(serializers.ModelSerializer):
    # 重写 username 字段让其时区字段自己的校验规则, 不然会出现 required 错误
    username = serializers.CharField()

    class Meta:
        model = models.UserInfo
        fields = ['username', 'password']

    def validate(self, attrs):
        username = attrs.get('username')
        password = attrs.get('password')
        # 多登入方式,username 可能是用户名、邮箱、手机号, 分情况操作
        if username.isdigit():
            user = models.UserInfo.objects.filter(Q(phone=int(username))).first()
        else:
            user = models.UserInfo.objects.filter(Q(email=username) | Q(username=username)).first()

        if user and user.check_password(password):
            # 登入成功, 签发 token
            payload = jwt_payload_handler(user)
            token = jwt_encode_handler(payload)
            # context 是上下文，是视图类和序列化类沟通的桥梁(管道)
            self.context['token'] = token
            self.context['username'] = username
            self.context['user_obj'] = user  # 将当前 user 对象也放进去
            return attrs
        else:
            raise ValidationError('用户名或密码错误!!')

views.py

from rest_framework.generics import CreateAPIView
from drf_test import models
from drf_test import serializer
from rest_framework.response import Response
from rest_framework.viewsets import ViewSetMixin

# 多种登入方式(继承 ViewSetMixin 自动生成路由)
class VariousLoginView(ViewSetMixin, CreateAPIView):
    queryset = models.UserInfo.objects.all()
    serializer_class = serializer.VariousLoginModelSerializer

    def create(self, request, *args, **kwargs):
        ser = self.get_serializer(data=request.data)
        if ser.is_valid():
            # 从 context 中取出序列化类传过来的数据
            token = ser.context['token']
            username = ser.context['username']
            user_obj = ser.context['user_obj']  # 拿到 user 对象
            return Response({'status': 200, 'msg': '登入成功!!', 'token': token, 'username': user_obj.username})
        else:
            return Response({'status': 100, 'msg': ser.errors})

用户名登入

35 JWT 认证

邮箱登入

35 JWT 认证

手机号登入

35 JWT 认证

只需要改写序列化类中的用户查询的代码

class VariousLoginModelSerializer(serializers.ModelSerializer):
    # 重写 username 字段让其时区字段自己的校验规则, 不然会出现 required 错误
    username = serializers.CharField()

    class Meta:
        model = models.UserInfo
        fields = ['username', 'password']

    def validate(self, attrs):
        username = attrs.get('username')
        password = attrs.get('password')

        # 多登入方式,username 可能是用户名、邮箱、手机号, 分情况操作
        if re.match('^1[3-9][0-9]{9}$', username):
            # 用手机号登录
            user = models.UserInfo.objects.filter(phone=username).first()
        elif re.match(r'^.+@.+$', username):  # 这里匹配不严谨(仅用于测试)
            # 以邮箱登录
            user = models.UserInfo.objects.filter(email=username).first()
        else:
            # 以用户名登录
            user = models.UserInfo.objects.filter(username=username).first()

        if user and user.check_password(password):
            payload = jwt_payload_handler(user)
            token = jwt_encode_handler(payload)
            self.context['token'] = token
            self.context['username'] = username
            self.context['user_obj'] = user
            return attrs
        else:
            raise ValidationError('用户名或密码错误!!')

正文完