JWT_携带jwt payload发送xhr请求-CSDN博客

本文链接：https://blog.csdn.net/qq_36811322/article/details/90406788

JWT

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

什么是JWT

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

起源

说起JWT，我们应该来谈一谈基于token的认证和传统的session认证的区别。

传统的session认证

我们知道，http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行，因为根据http协议，我们并不能知道是哪个用户发出的请求，所以为了让我们的应用能识别是哪个用户发出的请求，我们只能在服务器存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie,以便下次请求时发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了,这就是传统的基于session认证。

但是这种基于session的认证使应用本身很难得到扩展，随着不同客户端用户的增加，独立的服务器已无法承载更多的用户，而这时候基于session认证应用的问题就会暴露出来.

基于session认证所显露的问题

Session: 每个用户经过我们的应用认证之后，我们的应用都要在服务端做一次记录，以方便用户下次请求的鉴别，通常而言session都是保存在内存中，而随着认证用户的增多，服务端的开销会明显增大。

扩展性: 用户认证之后，服务端做认证记录，如果认证的记录被保存在内存中的话，这意味着用户下次请求还必须要请求在这台服务器上,这样才能拿到授权的资源，这样在分布式的应用上，相应的限制了负载均衡器的能力。这也意味着限制了应用的扩展能力。

CSRF: 因为是基于cookie来进行用户识别的, cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。

基于token的鉴权机制

基于token的鉴权机制类似于http协议也是无状态的，它不需要在服务端去保留用户的认证信息或者会话信息。这就意味着基于token认证机制的应用不需要去考虑用户在哪一台服务器登录了，这就为应用的扩展提供了便利。

流程上是这样的：

用户使用用户名密码来请求服务器
服务器进行验证用户的信息
服务器通过验证发送给用户一个token
客户端存储token，并在每次请求时附送上这个token值
服务端验证token值，并返回数据

这个token必须要在每次请求时传递给服务端，它应该保存在请求头里，另外，服务端要支持CORS(跨来源资源共享)策略，一般我们在服务端这么做就可以了Access-Control-Allow-Origin: *。

那么我们现在回到JWT的主题上。

JWT长什么样？

JWT是由三段信息构成的，将这三段信息文本用.链接一起就构成了Jwt字符串。就像这样:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

JWT的构成

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

jwt的头部承载两部分信息：

声明类型，这里是jwt
声明加密的算法通常直接使用 HMAC SHA256

完整的头部就像下面这样的JSON：

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

然后将头部进行base64加密（该加密是可以对称解密的),构成了第一部分.

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

payload

载荷就是存放有效信息的地方。这个名字像是特指飞机上承载的货品，这些有效信息包含三个部分

标准中注册的声明
公共的声明
私有的声明

标准中注册的声明 (建议但不强制使用) ：

iss: jwt签发者
sub: jwt所面向的用户
aud: 接收jwt的一方
exp: jwt的过期时间，这个过期时间必须要大于签发时间
nbf: 定义在什么时间之前，该jwt都是不可用的.
iat: jwt的签发时间
jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。

公共的声明 ：公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息，因为该部分在客户端可解密.

私有的声明 ：私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。

定义一个payload:

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

然后将其进行base64加密，得到JWT的第二部分。

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9

signature

JWT的第三部分是一个签证信息，这个签证信息由三部分组成：

header (base64后的)
payload (base64后的)
secret

这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分。

// javascript
var encodedString = base64UrlEncode(header) + '.' + base64UrlEncode(payload);

var signature = HMACSHA256(encodedString, 'secret'); // TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

将这三部分用.连接成一个完整的字符串,构成了最终的jwt:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

注意：secret是保存在服务器端的，jwt的签发生成也是在服务器端的，secret就是用来进行jwt的签发和jwt的验证，所以，它就是你服务端的私钥，在任何场景都不应该流露出去。一旦客户端得知这个secret, 那就意味着客户端是可以自我签发jwt了。

如何应用

一般是在请求头里加入Authorization，并加上Bearer标注：

fetch('api/user/1', {
  headers: {
    'Authorization': 'Bearer ' + token
  }
})

服务端会验证token，如果验证通过就会返回相应的资源。整个流程就是这样的:

jwt

总结

优点

因为json的通用性，所以JWT是可以进行跨语言支持的，像JAVA,JavaScript,NodeJS,PHP等很多语言都可以使用。
因为有了payload部分，所以JWT可以在自身存储一些其他业务逻辑所必要的非敏感信息。
便于传输，jwt的构成非常简单，字节占用很小，所以它是非常便于传输的。
它不需要在服务端保存会话信息, 所以它易于应用的扩展

安全相关

不应该在jwt的payload部分存放敏感信息，因为该部分是客户端可解密的部分。
保护好secret私钥，该私钥非常重要。
如果可以，请使用https协议

我们在验证完用户的身份后（检验用户名和密码），需要向用户签发JWT，在需要用到用户身份信息的时候，还需核验用户的JWT。

关于签发和核验JWT，我们可以使用Django REST framework JWT扩展来完成。

文档网站http://getblimp.github.io/django-rest-framework-jwt/

安装配置

安装

pip install djangorestframework-jwt

配置

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_jwt.authentication.JSONWebTokenAuthentication',
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.BasicAuthentication',
    ),
}

JWT_AUTH = {
    'JWT_EXPIRATION_DELTA': datetime.timedelta(days=1),
}

JWT_EXPIRATION_DELTA 指明token的有效期

使用

Django REST framework JWT 扩展的说明文档中提供了手动签发JWT的方法

from rest_framework_jwt.settings import api_settings

jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER

payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)

在注册成功后，连同返回token，需要在注册视图中创建token。

修改CreateUserSerializer序列化器，在create方法中增加手动创建token的方法

from rest_framework_jwt.settings import api_settings

class CreateUserSerializer(serializers.ModelSerializer):
    """
    创建用户序列化器
    """
    ...
    token = serializers.CharField(label='登录状态token', read_only=True)  # 增加token字段

    class Meta：
        ...
        fields = ('id', 'username', 'password', 'password2', 'sms_code', 'mobile', 'allow', 'token')  # 增加token
        ...

    def create(self, validated_data):
        """
        创建用户
        """
        # 移除数据库模型类中不存在的属性
        del validated_data['password2']
        del validated_data['sms_code']
        del validated_data['allow']
        user = super().create(validated_data)

        # 调用django的认证系统加密密码
        user.set_password(validated_data['password'])
        user.save()

        # 补充生成记录登录状态的token
        jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
        jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
        payload = jwt_payload_handler(user)
        token = jwt_encode_handler(payload)
        user.token = token

        return user

前端保存token

我们可以将JWT保存在cookie中，也可以保存在浏览器的本地存储里，我们保存在浏览器本地存储中

浏览器的本地存储提供了sessionStorage 和 localStorage 两种：

sessionStorage 浏览器关闭即失效
localStorage 长期有效

使用方法

sessionStorage.变量名 = 变量值   // 保存数据
sessionStorage.变量名  // 读取数据
sessionStorage.clear()  // 清除所有sessionStorage保存的数据

localStorage.变量名 = 变量值   // 保存数据
localStorage.变量名  // 读取数据
localStorage.clear()  // 清除所有localStorage保存的数据

在前端js/register.js文件中增加保存token

var vm = new Vue({
    ...
    methods: {
        ...
        on_submit: function(){
            axios.post(...)
                .then(response => {
                    // 记录用户的登录状态
                    sessionStorage.clear();
                    localStorage.clear();
                    localStorage.token = response.data.token;
                    localStorage.username = response.data.username;
                    localStorage.user_id = response.data.id;
                    location.href = '/index.html';
                })
                .catch(...)
        }
    }
})

jwt-token操作

# 安装 djangorestframework-jwt
#       -- pip3 install djangorestframework-jwt

# 采用 djangorestframework-jwt框架 产生 jwt规范的 token
from rest_framework_jwt.settings import api_settings
def get_jwt_token(user):
    # 自定义生成token，基于某user对象，且该user对象必须有username、password两个字段
    jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
    jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
    payload = jwt_payload_handler(user)
    token = jwt_encode_handler(payload)
    return token

项目开发的token处理

# token可以存储的位置：服务器、缓存、客户端

# 1.产生token: 对request操作形成 header.payload.signature
def token_encode(request):
    token = ""
    print(request)

    # 加密规则
    # 将request变成 "header.payload.signature"
    header_dic = {
        "lock_code": "base64"
    }
    header = base64.b64encode(json.dumps(header_dic).encode('utf-8'))
    payload = b"abc123"
    signature = b"000"
    token_data = b"%s.%s.%s" % (header, payload, signature)
    token = token_data.decode('utf-8')
    return token
# 在登录时，用token_encode产生token，丢给前台即可，服务器不用存储


# 2.解析token：从request中的token 解析出 header、payload、signature
def token_decode(request):
    token = request.META.get('HTTP_TOKEN')  # type: str

    header, payload, signature = token.split('.')
    # 解密规则
    # header校验，失败
    #    return None
    header_str = base64.b64decode(header.encode('utf-8'))
    header_dic = json.loads(header_str)
    if header_dic != {"lock_code": "base64"}:
        return None

    # payload校验，失败
    #    return None
    # signature校验，失败
    #    return None

    # 校验成功
    # return user, auth
# 在认证模块校验时，用token_decode校验token，不是查询UserToken数据库校验

权限认证

# app.models
class User(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)
    # 用户有不同的权限分类
    level = models.IntegerField(choices=((0, '普通用户'), (1, '超级用户')), default=0)
    
    
# app.auth
from rest_framework.permissions import BasePermission
class VisitPermission(BasePermission):
    message = '验证失败：权限不够！'
    def has_permission(self, request, view):
        # 1）拿到登录的用户
        user = request.user
        # 2）获取用户的权限
        # lever = user.level
        lever_str = user.get_level_display()
        # 3）权限判断
        if lever_str == '超级用户':
            return True  # 验证通过
        return False  # 验证失败

# app.views
from app import auth
class Books(APIView):
    permission_classes = [auth.VisitPermission]  # 局部使用
    def get(self, request):
        return Response({
            "status": 0,
            "msg": 'get books success',
            "results": [],
            "user_name": request.user.username
        })

# 了解：全局使用局部禁用
# settings
REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': (
        'app.auth.VisitPermission',
    )
}
# views
class Books(APIView):
    permission_classes = []  # 局部禁用

频率认证

# 项目开发
# app.auth
from rest_framework.throttling import SimpleRateThrottle
class VisitRateThrottle(SimpleRateThrottle):
    scope = "luffy"

    def get_cache_key(self, request, view):
        return self.get_ident(request)
        # return request.META.get('REMOTE_ADDR')  # 对IP进行频率限制
        # return request.user.username  # 对用户进行频率限制

# settings
REST_FRAMEWORK = {
    # 频率的配置 3/s 3/m 3/h 3/h
    'DEFAULT_THROTTLE_RATES': {
        'luffy': '3/m'  # 一分钟可以访问三次
    }
    # 全局配置
    'DEFAULT_THROTTLE_CLASSES': (
        'app.auth.VisitRateThrottle',
    )
}

# views
class Books(APIView):
    # 局部禁用
    throttle_classes = []

频率组件原理

class MyThrottle(BaseThrottle):
    # 存放ip与访问时间list的对应关系
    VISIT_RECORD = {}

    def __init__(self):
        # 存放某一访问者历史访问时间的
        self.history = None

    def allow_request(self, request, view):
        # 1) 取出访问者ip
        ip = request.META.get('REMOTE_ADDR')
        # 2) 获取当前时间
        import time
        ctime = time.time()
        # 3) 判断是否是第一次访问
        if ip not in self.VISIT_RECORD:
            self.VISIT_RECORD[ip] = [ctime, ]
            return True
        self.history = self.VISIT_RECORD.get(ip)
        # 4) 当前时间与最开始访问时间间隔超出60s则可以再次访问，移除最开始的访问时间
        while self.history and ctime - self.history[-1] > 60:
            self.history.pop()
        # 5) 访问频率的处理
        if len(self.history) < 3:
            self.history.insert(0, ctime)
            return True
        else:
            return False

    def wait(self):
        import time
        ctime = time.time()
        # 还要等多久才能访问
        return 60 - (ctime - self.history[-1])

分页

数据准备

# models
class Teacher(models.Model):
    name = models.CharField(max_length=32)
    salary = models.DecimalField(max_digits=5, decimal_places=2)
# objson
class TeacherJson(serializers.ModelSerializer):
    class Meta:
        model = models.Teacher
        fields = '__all__'
# urls
url(r'^teachers/', views.Teachers.as_view()),

# views
class Teachers(APIView):
    def post(self, request):
        list = []
        for i in range(1, 51):
            list.append(models.Teacher(name="%s老师" % i, salary=i))
        models.Teacher.objects.bulk_create(list)
        return Response({
            'status': 0,
            'msg': 'ok'
        })

简单分页

from rest_framework.pagination import PageNumberPagination
class Teachers(APIView):
    permission_classes = []
    throttle_classes = []
    throttle_classes = []
    def get(self, request):
        # 没有分页的所有数据
        teacher_list = models.Teacher.objects.all()

        # 完成分页
        # 1) 初始化分页对象
        page_simple = PageNumberPagination()

        # 2) 配置分页对象
        # page_simple.page_size = api_settings.PAGE_SIZE
        # 一页显示的条数
        page_simple.page_size = 5
        # /teachers/?pages=3  默认page
        page_simple.page_query_param = 'pages'
        # /teachers/?pages=3&line=10 用户可以自定义访问一页有多少条数据
        page_simple.page_size_query_param = 'line'
        # 限制用户自定义一页最大能访问的条数
        page_simple.max_page_size = 10

        # 3) 操作分页后一页的数据
        teacher_page_list = page_simple.paginate_queryset(teacher_list, request, self)
        
        # 将一页的数据序列化后返回给前台
        teacher_data = objson.TeacherJson(teacher_page_list, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'results': teacher_data
        })

偏移分页

from rest_framework.pagination import LimitOffsetPagination
class Teachers(APIView):
    def get(self, request):
        teacher_list = models.Teacher.objects.all()

        # 完成分页
        # 1) 初始化分页对象
        page_limit = LimitOffsetPagination()

        # 2) 配置分页对象
        # 一页显示的条数
        page_limit.default_limit = 5
        # 自定义一页获取的条数
        page_limit.limit_query_param = 'limit'
        # 从哪条数据开始查询
        page_limit.offset_query_param = 'offset'
        # 自定义最大获取一页的条数
        page_limit.max_limit = 8

        # 3) 操作分页数据
        teacher_page_list = page_limit.paginate_queryset(teacher_list, request, self)

        teacher_data = objson.TeacherJson(teacher_page_list, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'previous': page_limit.get_previous_link(),  # 上一页
            'next': page_limit.get_next_link(),  # 下一页
            'results': teacher_data
        })

        # return page_limit.get_paginated_response(teacher_data)  # 内部提供的Response对象

游标分页

from rest_framework.pagination import CursorPagination
class Teachers(APIView):
    def get(self, request):
        teacher_list = models.Teacher.objects.all()

        # 完成分页
        # 1) 初始化分页对象
        page_cursor = CursorPagination()

        # 2) 配置分页对象
        # 一页的条数
        page_cursor.page_size = 10
        # 排序的字段，可以正向也可以反向
        page_cursor.ordering = '-id'
        # 游标的关键字
        page_cursor.cursor_query_param = 'cursor'

        # 3) 操作分页数据
        teacher_page_list = page_cursor.paginate_queryset(teacher_list, request, self)

        teacher_data = objson.TeacherJson(teacher_page_list, many=True).data
        return Response({
            'status': 0,
            'msg': 'ok',
            'previous': page_cursor.get_previous_link(),  # 上一页
            'next': page_cursor.get_next_link(),  # 下一页
            'results': teacher_data
        })