JsonWebToken

概述

JSON Web Token（JWT）是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。

让我们来假想一下一个场景。在A用户关注了B用户的时候，系统发邮件给B用户，并且附有一个链接“点此关注A用户”。链接的地址可以是这样的

JWT (Json Web Token) 前后端分离项目 用的比较多的 认证方案

Cookie 和 Session / Token 都需要在后端存储数据

json格式的数据存储了当前登录的这个用户的一些信息 + 时间戳 + 加密算法 --》 Token

用户信息 《== 校验时间戳是否过期 《-- 解密 《-- Token

https://www.xxxx.com/make-friend/?from_user=B&target_user=A

组成

一个JWT实际上就是一个字符串，它由三部分组成，头部、载荷与签名。

头部（Header）

JWT头部用于描述关于该JWT的最基本的信息，例如其类型以及签名所用的算法等。这也可以被表示成一个JSON对象。

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

在这里，我们说明了这是一个JWT，并且我们所用的签名算法（后面会提到）是HS256算法。

对它也要进行Base64编码，之后的字符串就成了JWT的Header（头部）。

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

import json
import base64


header = {
    "typ": "JWT",
    "alg": "HS256"
}

header_string = base64.urlsafe_b64encode(json.dumps(header).encode("utf-8")).replace(b'=', b'')

载荷（Payload）

我们先将上面的添加好友的操作描述成一个JSON对象。其中添加了一些其他的信息，帮助今后收到这个JWT的服务器理解这个JWT。

{
    "iss": "LiuzhichaoJWT",
    "iat": int(time.time()),
    "exp": expire_time,
    "aud": "luffy",
    "sub": "target@example.com",
    "from_user": "B",
    "target_user": "A"
}

这里面的前五个字段都是由JWT的标准所定义的。

• iss: 该JWT的签发者

• sub: 该JWT所面向的用户

• aud: 接收该JWT的一方

• exp(expires): 什么时候过期，这里是一个Unix时间戳

• iat(issued at): 在什么时候签发的

这些定义都可以在标准中找到。

将上面的JSON对象进行[base64编码]可以得到下面的字符串。这个字符串我们将它称作JWT的Payload（载荷）。

eyJpc3MiOiJKb2huIFd1IEpXVCIsImlhdCI6MTQ0MTU5MzUwMiwiZXhwIjoxNDQxNTk0NzIyLCJhdWQiOiJ3d3cuZXhhbXBsZS5jb20iLCJzdWIiOiJqcm9ja2V0QGV4YW1wbGUuY29tIiwiZnJvbV91c2VyIjoiQiIsInRhcmdldF91c2VyIjoiQSJ9

# 载荷
import time
import base64
import json
expire_time = int(time.time() + 10)

payload = {
    "iss": "LiuzhichaoJWT",
    "iat": int(time.time()),
    "exp": expire_time,
    "aud": "luffy",
    "sub": "target@example.com",
    "from_user": "B",
    "target_user": "A"
}

json_payload = base64.urlsafe_b64encode(json.dumps(payload).encode("utf-8")).replace(b'=', b'')

print(json_payload)

签名（Signature）

将上面的两个编码后的字符串都用句号 .连接在一起（头部在前），就形成了

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJKb2huIFd1IEpXVCIsImlhdCI6MTQ0MTU5MzUwMiwiZXhwIjoxNDQxNTk0NzIyLCJhdWQiOiJ3d3cuZXhhbXBsZS5jb20iLCJzdWIiOiJqcm9ja2V0QGV4YW1wbGUuY29tIiwiZnJvbV91c2VyIjoiQiIsInRhcmdldF91c2VyIjoiQSJ9

最后，我们将上面拼接完的字符串用HS256算法进行加密。在加密的时候，我们还需要提供一个密钥（secret）。如果我们用 `liuzhichao` 作为密钥的话，那么就可以得到我们加密后的内容

rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

# 密钥
key = "#$%^&*()FGHJKRT"

string = b".".join([header_string, json_payload])

# 签名
sign = base64.urlsafe_b64encode(hmac.new(key.encode("utf-8"), string, hashlib.sha256).digest())

print(sign)

这一部分又叫做签名。

import time
import base64
import json
import hmac
import hashlib


#JWT=头部.载荷.签名

#头部
headers = {
    "typ": "JWT",     # 声明token类型
    "alg": "HS256"    # 声明你的签名算法
}
# 头部被base64编码
header_string = base64.urlsafe_b64encode(json.dumps(headers).encode("utf-8")).replace(b'=', b'')

# 载荷（用户信息）
payload = {
    "iss": "LiuzhichaoJWT",
    "iat": int(time.time()),
    "exp": int(time.time()) + 200,
    "aud": "luffy",
    # "sub": "target@example.com",

    #自定义自己的属性
    "username": "alex",
    "user_id": "101"
}
# 载荷被base64编码
payload_string = base64.urlsafe_b64encode(json.dumps(payload).encode("utf-8")).replace(b'=', b'')


# 签名
key = "#$%^&*()2321))(#13213"  # 密钥
# sign_data = b".".join([header_string, payload_string])
sign_data = "{}.{}".format(header_string.decode("utf-8"),payload_string.decode("utf-8")).encode("utf-8")

#
sign_string = base64.urlsafe_b64encode(hmac.new(key.encode("utf-8"), sign_data, hashlib.sha256).digest())


###jwt
jwt="{}.{}.{}".format(header_string.decode("utf-8"),payload_string.decode("utf-8"),sign_string.decode("utf-8"))

最后将这一部分签名也拼接在被签名的字符串后面，我们就得到了完整的JWT

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJKb2huIFd1IEpXVCIsImlhdCI6MTQ0MTU5MzUwMiwiZXhwIjoxNDQxNTk0NzIyLCJhdWQiOiJ3d3cuZXhhbXBsZS5jb20iLCJzdWIiOiJqcm9ja2V0QGV4YW1wbGUuY29tIiwiZnJvbV91c2VyIjoiQiIsInRhcmdldF91c2VyIjoiQSJ9.rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

于是，我们就可以将邮件中的URL改成

https://www.xxx.com/make-friend/?jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJKb2huIFd1IEpXVCIsImlhdCI6MTQ0MTU5MzUwMiwiZXhwIjoxNDQxNTk0NzIyLCJhdWQiOiJ3d3cuZXhhbXBsZS5jb20iLCJzdWIiOiJqcm9ja2V0QGV4YW1wbGUuY29tIiwiZnJvbV91c2VyIjoiQiIsInRhcmdldF91c2VyIjoiQSJ9.rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

这样就可以安全地完成关注好友的操作了！

签名的目的

最后一步签名的过程，实际上是对头部以及载荷内容进行签名。一般而言，加密算法对于不同的输入产生的输出总是不一样的。对于两个不同的输入，产生同样的输出的概率极其地小（有可能比我成世界首富的概率还小）。所以，我们就把“不一样的输入产生不一样的输出”当做必然事件来看待吧。

所以，如果有人对头部以及载荷的内容解码之后进行修改，再进行编码的话，那么新的头部和载荷的签名和之前的签名就将是不一样的。而且，如果不知道服务器加密的时候用的密钥的话，得出来的签名也一定会是不一样的。

服务器应用在接受到JWT后，会首先对头部和载荷的内容用同一算法再次签名。那么服务器应用是怎么知道我们用的是哪一种算法呢？别忘了，我们在JWT的头部中已经用 alg字段指明了我们的加密算法了。

如果服务器应用对头部和载荷再次以同样方法签名之后发现，自己计算出来的签名和接受到的签名不一样，那么就说明这个Token的内容被别人动过的，我们应该拒绝这个Token，返回一个HTTP 401 Unauthorized响应。

Base64是一种编码，是可逆的，那么信息不就被暴露了吗？

是的。

所以，在JWT中，不应该在载荷里面加入任何敏感的数据。在上面的例子中，我们传输的是用户的User ID。这个值实际上不是什么敏感内容，一般情况下被知道也是安全的。

但是像密码这样的内容就不能被放在JWT中了。如果将用户的密码放在了JWT中，那么怀有恶意的第三方通过Base64解码就能很快地知道你的密码了。

为什么进行签名校验？

签名算法共同的特点是整个过程是不可逆的， 在 jwt 中，消息体是透明的，使用签名可以保证消息不被篡改。

jwt 支持续签么？

不支持，一旦过期时间被修改，整个`jwt`串就变了

from django.contrib import admin
from django.urls import path
from django.conf.urls import url, include
from api.views import LoginApi, AuthApi

api_urlpatterns = [
    url(r'login/', LoginApi.as_view()),  # http://127.0.0.1:8000/api/login
    url(r'auth/', AuthApi.as_view()),
]

urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'api/', include(api_urlpatterns)),
]

from rest_framework import generics
from rest_framework.response import Response
from .serializers import LoginSerializer
from .authentication import JwtAuthentication
from rest_framework.views import APIView

class LoginApi(generics.CreateAPIView):
    serializer_class = LoginSerializer

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        if serializer.is_valid():
            resp = serializer.save()  # 调用的是LoginSerializer类中的create方法，需要自己去实现
            return Response({"jwt_token": resp})
        else:
            return Response(serializer.errors)

    def get(self, request):
        return Response(12321)

#pip install PyJWT
class AuthApi(APIView):

    authentication_classes = [JwtAuthentication,]

    def get(self, request):
        return Response("认证测试")

from rest_framework import serializers
import time
import base64
import json
import hmac
import hashlib
import jwt


class LoginSerializer(serializers.Serializer):
    username = serializers.CharField(required=True)
    password = serializers.CharField(required=True)

    ############模拟#############
    # def create(self, validated_data):
    #     # 头部
    #     header = {
    #         "typ": "JWT",  # 声明token类型
    #         "alg": "HS256"  # 声明你的签名算法
    #     }


    """headers 中一些固定参数名称的意义"""

    # jku: 发送JWK的地址；最好用HTTPS来传输
    # jwk: 就是之前说的JWK
    # kid: jwk的ID编号
    # x5u: 指向一组X509公共证书的URL
    # x5c: X509证书链
    # x5t：X509证书的SHA-1指纹
    # x5t#S256: X509证书的SHA-256指纹
    # typ: 在原本未加密的JWT的基础上增加了 JOSE 和 JOSE+ JSON。JOSE序列化后文会说及。适用于JOSE标头的对象与此JWT混合的情况。
    # crit: 字符串数组，包含声明的名称，用作实现定义的扩展，必须由 this->JWT的解析器处理。不常见。


    #     # 头部被base64编码
    #     header_string = base64.urlsafe_b64encode(json.dumps(header).encode("utf-8")).replace(b'=', b'')
    #
    #     # 载荷（用户信息）
    #     payload = {
    #         "iss": "LiuzhichaoJWT",
    #         "iat": int(time.time()),
    #         "exp": int(time.time()) + 200000,
    #         "aud": "luffy",
    #         # "sub": "target@example.com",
    #
    #         # 自定义自己的属性
    #         "username": "alex",
    #         "user_id": "101",
    #     }

    """payload 中一些固定参数名称的意义, 同时可以在payload中自定义参数"""

    # iss  【issuer】发布者的url地址
    # sub 【subject】该JWT所面向的用户，用于处理特定应用，不是常用的字段
    # aud 【audience】接受者的url地址
    # exp 【expiration】 该jwt销毁的时间；unix时间戳
    # nbf  【not before】 该jwt的使用时间不能早于该时间；unix时间戳
    # iat   【issued at】 该jwt的发布时间；unix 时间戳
    # jti    【JWT ID】 该jwt的唯一ID编号

    #     # 载荷被base64编码
    #     payload_string = base64.urlsafe_b64encode(json.dumps(payload).encode("utf-8")).replace(b'=', b'')
    #
    #     # 签名
    #     key = "#$%^&*()2321))(#13213"  # 密钥  一般都放配置文件
    #     # sign = b".".join([header_string, payload_string])
    #     sign = "{}.{}".format(header_string.decode("utf-8"), payload_string.decode("utf-8")).encode("utf-8")
    #
    #     #
    #     sign_string = base64.urlsafe_b64encode(hmac.new(key.encode("utf-8"), sign, hashlib.sha256).digest())
    #
    #     ###jwt_token
    #     jwt_token = "{}.{}.{}".format(header_string.decode("utf-8"), payload_string.decode("utf-8"),
    #                             sign_string.decode("utf-8"))
    #
    #     return jwt_token

    #############用模块############
    def create(self, validated_data):
        # 头部
        headers = {
            "typ": "JWT",  # 声明token类型
            "alg": "HS256"  # 声明你的签名算法
        }

        # 载荷（用户信息）
        payload = {
            "iss": "luffycity",
            "iat": int(time.time()),
            "exp": int(time.time()) + 200000,
            # "aud": "luffy",
            # "sub": "target@example.com",

            # 自定义自己的属性
            "username": "alex",
            "user_id": "101",
        }

        # 密钥
        key = "#$%^&*()2321))(#13213"  # 密钥  一般都放配置文件

        jwt_token = jwt.encode(payload,  # payload
                               key.encode("utf-8"),  # 进行加密签名的密钥
                               algorithm="HS256",  # 指明签名算法方式, 默认也是HS256
                               headers=headers
                               ).decode('utf-8')  # python3 编码后得到 bytes, 再进行解码(指明解码的格式), 得到一个str

        return jwt_token

    def validate(self, attrs):
        username = attrs.get("username")
        password = attrs.get("password")
        if username == "admin" and password == 'abc123':
            return attrs
        else:
            raise serializers.ValidationError("用户名密码错误...")

    def update(self, instance, validated_data):
        pass


class AuthSerializer(serializers.Serializer):
    def validate(self, attrs):
        # print(self.context.get("request")) # 获取request对象  rest_framework.request.Request
        # print(self.context.get("request")._request) # 获取原始的request对象 WSGIRequest
        return attrs

    def create(self, validated_data):
        return ""

from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
import jwt
import time
import base64
import json
import hmac
import hashlib


class JwtAuthentication(BaseAuthentication):
    ############模拟#############
    # def authenticate(self, request):
    #     jwt_token = request.META.get("HTTP_AUTHORIZATION")
    #     # 校验 jwt_token 是否合法
    #     jwt_token = jwt_token.encode("utf-8")
    #
    #     header_payload_string, sign_string = jwt_token.rsplit(b'.', 1)
    #     header_string, payload_string = header_payload_string.split(b'.', 1)
    #
    #     sign_string = sign_string if len(sign_string) % 2 == 0 else sign_string + b'='
    #     header_string = header_string if len(header_string) % 2 == 0 else header_string + b'='
    #     payload_string = payload_string if len(payload_string) % 2 == 0 else payload_string + b'='
    #
    #     header_data = base64.urlsafe_b64decode(header_string)
    #     # 获取到头部数据
    #     header = json.loads(header_data.decode("utf-8"))
    #     # 获取到载荷数据
    #     payload_data = base64.urlsafe_b64decode(payload_string)
    #     # 获取到签名
    #     sign = base64.urlsafe_b64decode(sign_string)
    #     # 获取签名算法
    #     alg = header.get('alg')
    #
    #     if not alg:
    #         print("没有算法")
    #         raise ValueError("alg is not null")
    #
    #     key = "#$%^&*()2321))(#13213"  # 密钥  一般都放配置文件
    #

    #     if not hmac.compare_digest(sign, hmac.new(key.encode("utf-8"), header_payload_string, hashlib.sha256).digest()):
    #         print("验证签名失败")
    #         raise AuthenticationFailed("验证签名失败...")
    #     # 校验过期时间
    #     payload = json.loads(payload_data.decode("utf-8"))
    #     if not payload.get("exp") > time.time():
    #         raise AuthenticationFailed("jwt_token过期了...")
    #     # 校验iss: 该JWT的签发者
    #     # 校验aud: 接收该JWT的一方
    #     # ...
    #     # ...
    #
    #     user_id = payload.get("user_id")
    #     from django.contrib.auth.models import User
    #     user_obj=User.objects.get(pk=user_id)
    #     return user_obj,None

    #############用模块############

    def authenticate(self, request):
        jwt_token = request.META.get("HTTP_AUTHORIZATION")
        # 校验 jwt_token 是否合法
        key = "#$%^&*()2321))(#13213"  # 密钥  一般都放配置文件

        if not jwt_token:
            raise AuthenticationFailed("没有携带jwt_token")

        payload = jwt.decode(jwt_token, key, issuer='luffycity', algorithm="HS256")
        user_id = payload.get("user_id")

        if user_id != "101":
            raise AuthenticationFailed("jwt_token认证失败...")
        return None, None

        # from django.contrib.auth.models import User
        # user_obj=User.objects.get(pk=user_id)
        # return user_obj,None