首页手记 JWT解决方案教程：新手入门指南

JWT解决方案教程：新手入门指南

标签：

安全 API

概述

JWT解决方案教程介绍了JSON Web Token的基本概念及其在网络应用中的主要用途，包括身份验证、授权和安全性通信等。文章详细解释了JWT的组成部分及其生成和验证过程，并提供了实际项目中的应用示例，帮助读者理解JWT的实际应用场景及其优势。

什么是JWT及其用途

JSON Web Token (JWT) 是一种开放标准 (RFC 7519)，用于在网络应用之间安全地传输信息。JWT 通常用于身份验证和授权，但也可以用于传递任何需要加密的信息。它使用 JSON 格式的数据结构，因此易于解析和使用。JWT 由三个部分组成：头部（Header）、载荷（Payload）和签名（Signature）。

JWT的主要用途

JWT 的主要用途包括：

身份验证: 使用 JWT，客户端可以向服务器发送认证信息，而不必每次请求都重新进行身份验证。例如，用户登录后，服务器可以发送一个 JWT 给客户端，客户端在每次请求时都可以使用这个 JWT 进行身份验证。
授权: 通过 JWT，服务器可以验证用户是否有权限访问特定资源。JWT 中可以包含用户的角色和权限等信息。
安全通信: 由于 JWT 包含签名，因此可以确保数据在传输过程中未被篡改。
单一登录: JWT 可以在多个子域或服务之间共享，实现单点登录（SSO）。
无状态数据交换: JWT 本身不存储状态，服务器可以使用 JWT 中的信息来决定是否允许访问，这使得服务器端不需要维护大量用户会话。

JWT的优点

安全性: JWT 使用加密算法来保证数据的完整性和安全性。
轻量级: JWT 相对较轻，适合在网络中传输。
可扩展性: JWT 可以携带多种信息，如用户ID、角色等。
无状态: 服务器不存储 JWT，减轻了服务器的负担。

JWT的缺点

安全性依赖于密钥: 如果密钥泄露，JWT 会被破解。
数据量有限: JWT 不适合携带大量的数据，因为它会增加传输的大小。
存储问题: 对于一些需要持久化存储的场景，JWT 不是最优选择。

JWT的基本组成部分

JWT 由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。

头部

头部通常包含两个部分：令牌的类型（即 JWT）和使用的加密算法。常见的算法包括 HS256（使用 HMAC 算法和 SHA-256 加密）、RS256（使用 RSA 算法和 SHA-256 加密）等。以下是一个示例头部：

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

载荷

载荷部分包含自定义的数据，通常包括声明（claims）。一些常见的内置声明包括：

iss：JWT 发送者。
sub：该 JWT 所面向的用户。
aud：接收 JWT 的一方。
exp：在什么时间点，该 JWT 将被废弃。
nbf：在什么时间点之前，该 JWT 不可用。
iat：JWT 的发布时间。
jti：JWT 的唯一标识符。

以下是一个包含自定义声明的载荷示例：

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

签名

签名部分用于保证 JWT 的完整性和安全性。它包括头部、载荷、以及一个密钥，通过签名算法生成。签名的生成过程如下：

将头部和载荷字符串用 Base64 编码。
使用编码后的头部和载荷，以及密钥，通过指定的算法生成签名。

例如，使用 HS256 算法和密钥 secret 生成签名：

import base64
import hashlib
import hmac

# 假设头部和载荷都已编码为 Base64
header_encoded = "eyJhbGciOiAiSFMyNTYifQ=="
payload_encoded = "eyJzdWIiOiAiMTIzNDU2Nzg5MCIsICJuYW1lIjogIkpvaG4gRG9lIiwgImFkbWluIjogdHJ1ZX0="

# 使用密钥生成签名
key = "secret".encode('utf-8')
signature = base64.b64encode(hmac.new(key, header_encoded + "." + payload_encoded, hashlib.sha256).digest())

生成的完整 JWT 将是 header_encoded、payload_encoded 和 signature 三部分通过.连接在一起的字符串。

如何生成和验证JWT

生成和验证 JWT 的过程涉及几个步骤，包括编码头部和载荷、生成签名、验证签名等。

生成JWT

生成 JWT 的基本步骤如下：

编码头部：将头部转换为 JSON 格式，然后用 Base64 编码。
编码载荷：将载荷转换为 JSON 格式，然后用 Base64 编码。
生成签名：使用编码后的头部、载荷及密钥，通过指定的算法生成签名。

例如，使用 Python 生成 JWT：

import base64
import hashlib
import hmac
import json
from datetime import datetime, timedelta

def encode_base64(s):
    return base64.urlsafe_b64encode(s.encode('utf-8')).decode('utf-8').rstrip('=')

def generate_jwt(header, payload, secret):
    header_encoded = encode_base64(json.dumps(header))
    payload_encoded = encode_base64(json.dumps(payload))
    signature = base64.urlsafe_b64encode(hmac.new(secret.encode('utf-8'), header_encoded + "." + payload_encoded, hashlib.sha256).digest()).decode('utf-8').rstrip('=')
    return f"{header_encoded}.{payload_encoded}.{signature}"

header = {"alg": "HS256", "typ": "JWT"}
payload = {
    "sub": "1234567890",
    "name": "John Doe",
    "admin": True,
    "exp": (datetime.now() + timedelta(minutes=30)).timestamp()
}
secret = "secret"

jwt_token = generate_jwt(header, payload, secret)
print(jwt_token)

验证JWT

验证 JWT 的基本步骤如下：

拆分 JWT：将 JWT 字符串拆分为头部、载荷和签名三部分。
解码头部和载荷：用 Base64 解码头部和载荷，还原为 JSON 格式。
重新计算签名：使用解码后的头部、载荷和密钥，通过指定的算法重新计算签名。
比较签名：将重新计算的签名与 JWT 中的签名进行比较，如果一致则 JWT 有效。

例如，使用 Python 验证 JWT：

import base64
import hashlib
import hmac
import json
from datetime import datetime

def decode_base64(s):
    missing_padding = len(s) % 4
    if missing_padding:
        s += '=' * (4 - missing_padding)
    return base64.urlsafe_b64decode(s).decode('utf-8')

def verify_jwt(token, secret):
    parts = token.split('.')
    header = json.loads(decode_base64(parts[0]))
    payload = json.loads(decode_base64(parts[1]))
    signature = decode_base64(parts[2])

    new_signature = base64.urlsafe_b64encode(hmac.new(secret.encode('utf-8'), parts[0] + "." + parts[1], hashlib.sha256).digest()).decode('utf-8').rstrip('=')
    if signature == new_signature:
        return True
    return False

secret = "secret"
token = "eyJhbGciOiAiSFMyNTYiLCAidHlwIjogIkpXVCJ9.eyJzdWIiOiAiMTIzNDU2Nzg5MCIsICJuYW1lIjogIkpvaG4gRG9lIiwgImFkbWluIjogdHJ1ZSwgImV4cCI6IDE2Mjg5NjU4MDN9.7f7or5bl5U5v107wD6pH5g1B1s3eD1Q34s3eD1Q3"

if verify_jwt(token, secret):
    print("JWT is valid")
else:
    print("JWT is invalid")

使用JWT时的常见问题及解决方法

问题1：JWT密钥泄露

问题描述：如果 JWT 的密钥被泄露，攻击者可以伪造令牌，破坏系统的安全性。

解决方法：使用更复杂的密钥，定期更换密钥，并使用密钥管理工具来保护密钥。

import secrets

# 生成一个安全的随机密钥
secret_key = secrets.token_urlsafe(32)
print(f"Generated secret key: {secret_key}")

问题2：JWT安全性问题

问题描述：JWT 本身是一个字符串，如果其内容被泄露，攻击者可以访问用户的敏感信息。

解决方法：确保 JWT 通过 HTTPS 传输，使用安全的加密算法（如 HS256 或 RS256），并定期检查 JWT 的内容是否被篡改。

# 示例：生成一个包含安全信息的 JWT
header = {"alg": "HS256", "typ": "JWT"}
payload = {
    "sub": "1234567890",
    "name": "John Doe",
    "admin": True,
    "exp": (datetime.now() + timedelta(minutes=30)).timestamp()
}
secret = "secret"

jwt_token = generate_jwt(header, payload, secret)
print(jwt_token)

问题3：JWT过期时间设置不当

问题描述：如果 JWT 的过期时间设置得太短，用户需要频繁登录；如果设置得太长，会造成安全风险。

解决方法：设置合理的过期时间，通常建议在 1 到 24 小时之间。可以使用长寿命令牌和短寿命令牌相结合的方式，以提高安全性。

# 示例：生成一个包含较短过期时间的 JWT
exp = (datetime.now() + timedelta(minutes=30)).timestamp()
jwt_token = generate_jwt(header, payload, secret)
print(f"Short-lived JWT token: {jwt_token}")

# 示例：生成一个包含较长过期时间的 JWT
exp_long = (datetime.now() + timedelta(hours=24)).timestamp()
payload_long = {"sub": "1234567890", "name": "John Doe", "admin": True, "exp": exp_long}
jwt_token_long = generate_jwt(header, payload_long, secret)
print(f"Long-lived JWT token: {jwt_token_long}")

问题4：JWT载荷过大

问题描述：JWT 载荷过大可能会增加传输的大小，导致性能下降。

解决方法：将敏感数据存储在服务器端，只在 JWT 中存储必要的最小信息。可以使用数据库或缓存机制来存储用户信息，减少 JWT 的大小。

# 示例：生成一个包含最小信息的 JWT
payload_min = {"sub": "1234567890", "exp": (datetime.now() + timedelta(minutes=30)).timestamp()}
jwt_token_min = generate_jwt(header, payload_min, secret)
print(f"JWT token with minimal payload: {jwt_token_min}")

问题5：JWT生成和验证性能问题

问题描述：频繁生成和验证 JWT 可能会对系统性能产生影响。

解决方法：优化 JWT 的生成和验证过程，使用缓存机制，减少不必要的计算和 IO 操作。使用高性能的加密算法和库，如 PyJWT 或 jsonwebtoken。

# 示例：优化 JWT 验证过程
from jwt import PyJWT

jwt_library = PyJWT()
token = jwt_library.encode(payload, secret, algorithm='HS256')
print(f"Optimized JWT token: {token}")

is_valid = jwt_library.decode(token, secret, algorithms=['HS256'])
print(f"Is token valid? {is_valid}")

问题6：JWT存储问题

问题描述：JWT 通常存储在客户端（如浏览器的 LocalStorage 或 cookies），可能导致安全风险。

解决方法：使用 HTTP-only cookies 来存储 JWT，避免客户端直接访问 JWT。或者使用安全的存储方案，如服务器端的会话机制。

# 示例：使用 HTTP-only cookies 存储 JWT
from flask import Flask, request, make_response

app = Flask(__name__)
SECRET_KEY = "secret"

@app.route('/login', methods=['POST'])
def login():
    username = request.json.get('username')
    password = request.json.get('password')
    # 假设验证用户身份逻辑
    if username == "user" and password == "password":
        payload = {
            "username": username,
            "exp": datetime.utcnow() + timedelta(minutes=30)
        }
        token = jwt.encode(payload, SECRET_KEY, algorithm='HS256')
        response = make_response(jsonify({'message': 'Login successful'}))
        response.set_cookie('JWT', token, httponly=True)
        return response
    return jsonify({'message': 'Invalid credentials'}), 401

@app.route('/protected', methods=['GET'])
def protected():
    token = request.cookies.get('JWT')
    if not token:
        return jsonify({'message': 'Missing token'}), 401
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
        username = payload.get('username')
        return jsonify({'message': f'Hello, {username}!'})
    except jwt.ExpiredSignatureError:
        return jsonify({'message': 'Token expired'}), 401
    except jwt.InvalidTokenError:
        return jsonify({'message': 'Invalid token'}), 401

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

JWT在实际项目中的应用示例

示例1：身份验证

在用户登录时，服务器生成一个 JWT 并将其发送给客户端。客户端在后续请求中携带 JWT 进行认证。

示例代码

import jwt
from flask import Flask, request, jsonify

app = Flask(__name__)
SECRET_KEY = "secret"

@app.route('/login', methods=['POST'])
def login():
    username = request.json.get('username')
    password = request.json.get('password')
    # 假设验证用户身份逻辑
    if username == "user" and password == "password":
        payload = {
            "username": username,
            "exp": datetime.utcnow() + timedelta(minutes=30)
        }
        token = jwt.encode(payload, SECRET_KEY, algorithm='HS256')
        return jsonify({'token': token})
    return jsonify({'message': 'Invalid credentials'}), 401

@app.route('/protected', methods=['GET'])
def protected():
    token = request.headers.get('Authorization')
    if not token:
        return jsonify({'message': 'Missing token'}), 401
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
        username = payload.get('username')
        return jsonify({'message': f'Hello, {username}!'})
    except jwt.ExpiredSignatureError:
        return jsonify({'message': 'Token expired'}), 401
    except jwt.InvalidTokenError:
        return jsonify({'message': 'Invalid token'}), 401

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

示例2：授权

服务器使用 JWT 中的用户角色信息来决定是否允许用户访问特定资源。

示例代码

import jwt
from flask import Flask, request, jsonify

app = Flask(__name__)
SECRET_KEY = "secret"

@app.route('/login', methods=['POST'])
def login():
    username = request.json.get('username')
    password = request.json.get('password')
    # 假设验证用户身份逻辑
    if username == "user" and password == "password":
        payload = {
            "username": username,
            "role": "user",
            "exp": datetime.utcnow() + timedelta(minutes=30)
        }
        token = jwt.encode(payload, SECRET_KEY, algorithm='HS256')
        return jsonify({'token': token})
    return jsonify({'message': 'Invalid credentials'}), 401

@app.route('/protected', methods=['GET'])
def protected():
    token = request.headers.get('Authorization')
    if not token:
        return jsonify({'message': 'Missing token'}), 401
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
        username = payload.get('username')
        role = payload.get('role')
        if role == "admin":
            return jsonify({'message': f'Hello, {username}! You are an admin.'})
        return jsonify({'message': f'Hello, {username}! You are a user.'})
    except jwt.ExpiredSignatureError:
        return jsonify({'message': 'Token expired'}), 401
    except jwt.InvalidTokenError:
        return jsonify({'message': 'Invalid token'}), 401

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

示例3：单一登录（SSO）

使用 JWT 实现多个子域或服务之间的单点登录。

示例代码

import jwt
from flask import Flask, request, jsonify

app = Flask(__name__)
SECRET_KEY = "secret"

@app.route('/login', methods=['POST'])
def login():
    username = request.json.get('username')
    password = request.json.get('password')
    # 假设验证用户身份逻辑
    if username == "user" and password == "password":
        payload = {
            "username": username,
            "exp": datetime.utcnow() + timedelta(minutes=30)
        }
        token = jwt.encode(payload, SECRET_KEY, algorithm='HS256')
        return jsonify({'token': token})
    return jsonify({'message': 'Invalid credentials'}), 401

@app.route('/service1', methods=['GET'])
def service1():
    token = request.headers.get('Authorization')
    if not token:
        return jsonify({'message': 'Missing token'}), 401
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
        username = payload.get('username')
        return jsonify({'message': f'Hello, {username}!'})
    except jwt.ExpiredSignatureError:
        return jsonify({'message': 'Token expired'}), 401
    except jwt.InvalidTokenError:
        return jsonify({'message': 'Invalid token'}), 401

@app.route('/service2', methods=['GET'])
def service2():
    token = request.headers.get('Authorization')
    if not token:
        return jsonify({'message': 'Missing token'}), 401
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
        username = payload.get('username')
        return jsonify({'message': f'Hello, {username}!'})
    except jwt.ExpiredSignatureError:
        return jsonify({'message': 'Token expired'}), 401
    except jwt.InvalidTokenError:
        return jsonify({'message': 'Invalid token'}), 401

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

通过这些示例，可以更好地理解 JWT 的实际应用场景及其优势。在开发项目时，结合具体的业务需求，合理选择和使用 JWT，可以有效提升系统的安全性、可扩展性和用户体验。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

德玛西亚99

手记
篇

粉丝

92

获赞与收藏

559

关注作者，订阅最新文章

阅读免费教程

Java 并发原理入门教程

26个小节 39001 568

HTTP 入门教程

28个小节 37847 650

Hibernate 入门教程

29个小节 6370 94

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

JWT解决方案教程：新手入门指南

JWT的主要用途

JWT的优点

JWT的缺点

头部

载荷

签名

生成JWT

验证JWT

问题1：JWT密钥泄露

问题2：JWT安全性问题

问题3：JWT过期时间设置不当

问题4：JWT载荷过大

问题5：JWT生成和验证性能问题

问题6：JWT存储问题

示例1：身份验证

示例代码

示例2：授权

示例代码

示例3：单一登录（SSO）

示例代码

阅读免费教程