介绍

jwt（JSON Web Tokens），在用户认证当中常用的方式，在如今的前后端分离项目当中应用广泛

传统token和jwt区别

• 传统token：服务端会对登录成功的用户生成一个随机token返回，同时也会在本地保留对应的token（如在数据库中存入：token、用户名、过期时间等），当用户再次访问时，会携带之前的token给服务端进行校验，服务端则通过与本地保留的token进行对比，若寻找到符合条件的token数据，则校验成功

• jwt：服务端会对登录成功的用户生成一个随机token返回，但并不会在服务端本地保留（这是jwt和传统token最大的区别），而当用户再次访问时，服务端会基于jwt对token进行校验和解码（由于jwt是基于base64url编码，因此是可以反向解码的，所以一定要小心token泄漏的问题，以及不要在token中存放敏感数据，可以在：https://jwt.io/里解码基于jwt生成的token）

安装

pip install pyjwt

简单示例

import jwt
import time

headers = {
  "alg": "HS256",
  "typ": "JWT"
}
# 设置headers，即加密算法的配置
salt = "asgfdgerher"
# 随机的salt密钥，只有token生成者（同时也是校验者）自己能有，用于校验生成的token是否合法
exp = int(time.time() + 1)
# 设置超时时间：当前时间的100s以后超时
payload = {
  "name": "dawsonenjoy",
  "exp": exp
}
# 配置主体信息，一般是登录成功的用户之类的，因为jwt的主体信息很容易被解码，所以不要放敏感信息
# 当然也可以将敏感信息加密后再放进payload

token = jwt.encode(payload=payload, key=salt, algorithm='HS256', headers=headers).decode('utf-8')
# 生成token
print(token)

info = jwt.decode(token, salt, True, algorithm='HS256')
# 解码token，第二个参数用于校验
# 第三个参数代表是否校验，如果设置为False，那么只要有token，就能够对其进行解码
print(info)

time.sleep(2)
# 等待2s后再次验证token，因超时将导致验证失败
try:
    info = jwt.decode(token, salt, True, algorithm='HS256')
    print(info)
except Exception as e:
    print(repr(e))

info = jwt.decode(token, '', False, algorithm='HS256')
# 第三个参数设置为False，不进行校验，直接解码token
print(info)

结果：
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoiZGF3c29uZW5qb3kiLCJleHAiOjE1NzgzODUwMDl9.pL2zyBUvlJA6blZG_8W9CwXEgFFKkhE-IOSC8WX9MYE
{'name': 'dawsonenjoy', 'exp': 1578385009}
ExpiredSignatureError('Signature has expired',)
{'name': 'dawsonenjoy', 'exp': 1578385009}

可以看到第一次校验是成功的，到了第二次解密时因为已经过期，从而抛出过期异常，第三次因为不进行校验，所以直接给出解码信息

jwt生成token所需字段

生成token时，首先需要传入一些字段，主要包括：

• headers：主要配置一些加密的算法
• payload：规范当中有以下标准字段，但不是绝对：

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

• secret_key：签名密钥，示例代码里写的是salt，用于校验token的有效、合法性

jwt生成token过程

由上面的简单示例可以看出，jwt生成的token主要有三部分，用.隔开，分别代表：编码后的headers、payload，以及校验字段。
具体过程：

• 通过对headers的json数据进行base64url编码生成第一部分
• 通过对payload的json数据进行base64url编码生成第二部分
• 将第一部分和第二部分通过.拼接起来，然后对拼接后的内容结合签名密钥进行HS256加密生成密文（加密算法可以自己选，默认HS256），然后再进行base64url编码，从而生成第三部分
• 三个部分通过.拼接起来，作为token

base64url编码：先进行base64编码，然后将其中的+替换成-、/替换成_，并且最后一般会将=都去掉

这里简单模拟一下jwt的生成（参照了一下源码）：

import jwt
import time
import json
import base64
import hashlib
import hmac

headers = {
    "typ": "JWT",
    "alg": "HS256"
}
salt = "asgfdgerher"
exp = time.time() + 1
payload = {
  "name": "dawsonenjoy",
  "exp": exp
}

token = jwt.encode(payload=payload, key=salt, algorithm='HS256', headers=headers).decode('utf-8')
# 实际生成
first = base64.urlsafe_b64encode(json.dumps(headers, separators=(',', ':')).encode('utf-8').replace(b'=', b'')).decode('utf-8').replace('=', '')
# 模拟第一部分生成
second = base64.urlsafe_b64encode(json.dumps(payload, separators=(',', ':')).encode('utf-8').replace(b'=', b'')).decode('utf-8').replace('=', '')
# 模拟第二部分生成
first_second = f"{first}.{second}"
# 拼接前两部分
third = base64.urlsafe_b64encode(hmac.new(salt.encode('utf-8'), first_second.encode('utf-8'), hashlib.sha256).digest()).decode('utf-8').replace('=', '')
# 模拟第三部分生成
my_token = ".".join([first, second, third])
print(token)
print(my_token)
print(token == my_token)
# 可以看出结果是一样的

# 结果：
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoiZGF3c29uZW5qb3kiLCJleHAiOjE1Nzg1NTQxMjcuOTkwNDQ0N30.0XYnGgXXb3HrJzfoYsu-9IfqJs4GwTvf6H8uYIH78LY
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoiZGF3c29uZW5qb3kiLCJleHAiOjE1Nzg1NTQxMjcuOTkwNDQ0N30.0XYnGgXXb3HrJzfoYsu-9IfqJs4GwTvf6H8uYIH78LY
True

可以看出整体生成的就是一样的（毕竟就是参照源码写的）

jwt校验和解码过程

• 对于获取到的token，首先基于.将其切割成三个部分
• 对第二段进行base64url解码，并获取payload信息，检查token是否超时
• 将第一段和第二段拼接，并结合签名密钥进行HS256加密（默认HS256，选择和加密时一样的算法就行了），生成校验字段
• 将第三段进行base64url解码，判断是否和上一步生成的校验字段相同，相同则说明token有效

jwt常见异常处理

jwt校验抛出的异常类基本都在jwt和jwt.exceptions下，举例：

import jwt
import time
from jwt import exceptions

headers = {
  "alg": "HS256",
  "typ": "JWT"
}
salt = "asgfdgerher"
exp = int(time.time() - 1)
# 设置立即失效
payload = {
  "name": "dawsonenjoy",
  "exp": exp
}

token = jwt.encode(payload=payload, key=salt, algorithm='HS256', headers=headers).decode('utf-8')
try:
    info = jwt.decode(token, salt, True, algorithm='HS256')
    print(info)
except exceptions.ExpiredSignatureError:
    print('token已失效')
except jwt.DecodeError:
    print('token认证失败')
except jwt.InvalidTokenError:
    print('非法的token')

WEB开发中简单示例

基于传统token

首先我们来看看使用传统的token的示例（这里基于flask，使用全局字典模拟数据库来演示）：

# 基于传统token实现用户校验
from flask import Flask, request
import json
import uuid

app = Flask(__name__)

# 这里用全局字典模拟数据库：
# user_table表里存放用户名、密码用于用户登录校验
# user_token表里存放token，用于token校验
# user_info_table存放用户信息
db_source = {
    'user_table': {
        'dawsonenjoy': {
            'pwd': '111111'
        }
    }, 
    'user_token': {},
    'user_info_table': {
        'dawsonenjoy': {
            'age': 18
        }
    }
}

@app.route('/login', methods=['POST'])
def login():
    '''用户登录，用户名密码验证成功将会生成对应token，并将token保存以及返回给用户'''
    username = request.form.get('username', None)
    pwd = request.form.get('password', None)
    if (not username) or (not pwd):
        return json.dumps({'status': 1, 'code': '400', 'msg': '用户或密码不允许为空！'}, ensure_ascii=False)
    if not db_source['user_table'].get(username, None):
        return json.dumps({'status': 1, 'code': '401', 'msg': '用户不存在！'}, ensure_ascii=False)
    if db_source['user_table'][username]['pwd'] != pwd:
        return json.dumps({'status': 1, 'code': '402', 'msg': '用户名或密码错误！'}, ensure_ascii=False)
    # 当登录校验通过，则为用户存入token，并返回token
    token = str(uuid.uuid4())
    db_source['user_token'][token] = username
    return json.dumps({'status': 1, 'code': '200', 'data': {'token': token}})

@app.route('/user_info', methods=['GET'])
def user_info():
    '''查看用户信息，需要和本地保存的token进行校验'''
    token = request.args.get('token', None)
    if not token:
        return json.dumps({'status': 1, 'code': '500', 'msg': 'token不允许为空！'}, ensure_ascii=False)
    if not db_source['user_token'].get(token, None):
        return json.dumps({'status': 1, 'code': '501', 'msg': 'token校验失败！'}, ensure_ascii=False)
    # 当token校验成功则返回用户信息
    username = db_source['user_token'][token]
    info = db_source['user_info_table'][username]
    return json.dumps({'status': 1, 'code': '200', 'data': {username: info}})

if __name__ == '__main__':
    app.run(debug=True, port=5000)

基于jwt

为了更好地对比（主要是懒得再写代码），这里就基于前面代码该进成基于jwt版本的校验，代码示例如下：

# 基于jwt实现的用户校验
from flask import Flask, request
import jwt
from jwt import exceptions
import json
import time

app = Flask(__name__)

# 这里用全局字典模拟数据库：
# user_table表里存放用户名、密码用于用户登录校验
# 因为jwt校验无需在服务端存储，所以user_token表也就不需要
# user_info_table存放用户信息
db_source = {
    'user_table': {
        'dawsonenjoy': {
            'pwd': '111111'
        }
    }, 
    'user_info_table': {
        'dawsonenjoy': {
            'age': 18
        }
    }
}

SECRET_KEY = "asgfddasdasdasgerher"
# 定义签名密钥，用于校验jwt的有效、合法性

def create_token(name):
    '''基于jwt创建token的函数'''
    global SECRET_KEY
    headers = {
        "alg": "HS256",
        "typ": "JWT"
    }
    exp = int(time.time() + 20)
    payload = {
        "name": name,
        "exp": exp
    }
    token = jwt.encode(payload=payload, key=SECRET_KEY, algorithm='HS256', headers=headers).decode('utf-8')
    # 返回生成的token
    return token

def validate_token(token):
    '''校验token的函数，校验通过则返回解码信息'''
    global SECRET_KEY
    payload = None
    msg = None
    try:
        payload = jwt.decode(token, SECRET_KEY, True, algorithm='HS256')
        # jwt有效、合法性校验
    except exceptions.ExpiredSignatureError:
        msg = 'token已失效'
    except jwt.DecodeError:
        msg = 'token认证失败'
    except jwt.InvalidTokenError:
        msg = '非法的token'
    return (payload, msg)

@app.route('/login', methods=['POST'])
def login():
    '''用户登录，用户名密码验证成功将会生成对应token，但不需要在本地保存，直接返回给用户'''
    username = request.form.get('username', None)
    pwd = request.form.get('password', None)
    if (not username) or (not pwd):
        return json.dumps({'status': 1, 'code': '400', 'msg': '用户或密码不允许为空！'}, ensure_ascii=False)
    if not db_source['user_table'].get(username, None):
        return json.dumps({'status': 1, 'code': '401', 'msg': '用户不存在！'}, ensure_ascii=False)
    if db_source['user_table'][username]['pwd'] != pwd:
        return json.dumps({'status': 1, 'code': '402', 'msg': '用户名或密码错误！'}, ensure_ascii=False)
    # 当登录校验通过，则为用户创建并返回token
    token = create_token(username)
    # 注意这里不存入本地了
    return json.dumps({'status': 1, 'code': '200', 'data': {'token': token}})

@app.route('/user_info', methods=['GET'])
def user_info():
    '''查看用户信息，需要token校验'''
    token = request.args.get('token', None)
    if not token:
        return json.dumps({'status': 1, 'code': '500', 'msg': 'token不允许为空！'}, ensure_ascii=False)
    payload, msg = validate_token(token)
    # 直接对token进行合法性校验
    if msg:
        return json.dumps({'status': 1, 'code': '500', 'msg': msg}, ensure_ascii=False)
    username = payload['name']
    info = db_source['user_info_table'][username]
    return json.dumps({'status': 1, 'code': '200', 'data': {username: info}})

if __name__ == '__main__':
    app.run(debug=True, port=5000)

参考
https://pythonav.com/wiki/detail/6/67/

其他相关库

itsdangerous

一个基于jwt再封装了一层的库，方便我们对jwt的使用，简单示例：

# pip install itsdangerous
from itsdangerous import TimedJSONWebSignatureSerializer as TJWSS, SignatureExpired, BadData
import time

salt = "adsafergberhere"
payload = {
    "name": "dawsonenjoy",
}
tjwss = TJWSS(salt, 1)
# 实例化jwt序列化对象，设置salt和超时时间，这里设置1s后超时
token = tjwss.dumps(payload).decode()
# 编码payload数据，生成token
data = tjwss.loads(token)
# 校验和解码token
print(data)

time.sleep(2)
# 2s后让token超时
try:
    print(tjwss.loads(token))
except SignatureExpired:
    print("token超时")
except BadData:
    print("认证失败")

djangorestframework-jwt

DFM框架中的jwt插件，安装：

pip install djangorestframework
pip install djangorestframework-jwt

参考：
https://www.jianshu.com/p/740a0320f960
https://www.jianshu.com/p/a399b98ab05b