ToB企服应用市场:ToB评测及商务社交产业平台

标题: PyJWT 和 python-jose 在处理JWT令牌处理的时候的差异和详细使用 [打印本页]

---

作者: 卖不甜枣    时间: 2024-8-27 09:35
标题: PyJWT 和 python-jose 在处理JWT令牌处理的时候的差异和详细使用
PyJWT 和 python-jose 是两个用于处理 JSON Web Tokens (JWT) 的 Python 库。它们都有助于天生、解码、验证和管理 JWT，但它们在功能范围和设计哲学上有一些重要的区别。本篇先容它们之间的一些差异，以及在项目中使用FastAPI+ python-jose 来处理访问令牌的天生以及一些例子代码供参考。
1、PyJWT 和 python-jose的差异

PyJWT

PyJWT 是一个专门处理 JWT 的 Python 库，它旨在简化 JWT 的创建和验证。
特点：

• 专注于 JWT: PyJWT 专门用于 JWT 的处理，不提供其他类型的加密或签名功能。
  
• 简朴易用: PyJWT 提供了简朴的 API，用于创建和验证 JWT。
  
• 支持常见的签名算法: 包罗 HMAC (HS256, HS384, HS512) 和 RSA (RS256, RS384, RS512)。
  
• 轻量级: 由于 PyJWT 专注于 JWT，依赖少，安装和使用都很简便。
  

主要用法示例：

1. import jwt
2. import datetime
4. # 创建一个JWT
5. payload = {
6.     "user_id": 123,
7.     "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=1)
8. }
9. secret = 'your-secret-key'
10. token = jwt.encode(payload, secret, algorithm='HS256')
12. # 解码JWT
13. decoded = jwt.decode(token, secret, algorithms=['HS256'])
14. print(decoded)

复制代码

python-jose

python-jose 是一个更广泛的加密库，它不但支持 JWT，还支持多种 JOSE (JSON Object Signing and Encryption) 标准，包罗 JWS (JSON Web Signature)、JWE (JSON Web Encryption)、JWK (JSON Web Key)、JWA (JSON Web Algorithms) 等。
特点：

• 全面的 JOSE 支持: 除了 JWT，python-jose 还支持其他 JOSE 标准，因此功能更强大、更灵活。
  
• 多种加密与签名算法: 支持比 PyJWT 更多的算法，如直接加密 (dir)、对称密钥加密 (A256KW, A192KW, A128KW)，以及 RSA 和 ECDSA 的多种模式。
  
• 丰富的功能: 提供更细粒度的控制，适合需要复杂加密和签名操纵的应用场景。
  
• 相对复杂: 由于功能更广泛，python-jose 的使用复杂度比 PyJWT 更高。
  

主要用法示例：

1. from jose import jwt
2. from jose.exceptions import JWTError
4. # 创建一个JWT
5. payload = {
6.     "user_id": 123,
7.     "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=1)
8. }
9. secret = 'your-secret-key'
10. token = jwt.encode(payload, secret, algorithm='HS256')
12. # 解码JWT
13. try:
14.     decoded = jwt.decode(token, secret, algorithms=['HS256'])
15.     print(decoded)
16. except JWTError as e:
17.     print(f"Token is invalid: {e}")

复制代码

差异总结

• 功能范围: PyJWT 专注于 JWT，适合需要简朴 JWT 处理的项目；python-jose 则支持整个 JOSE 标准，适合需要更复杂加密和签名操纵的项目。
  
• 易用性: PyJWT API 简朴，易于上手；python-jose 更强大，但同时也更复杂。
  
• 算法支持: python-jose 支持的算法更广泛，尤其是在需要高级加密或签名场景时更具优势。
  
• 使用场景: 假如你的项目只需要天生和验证 JWT，PyJWT 是一个不错的选择；假如你需要全面的 JOSE 支持，包罗 JWS、JWE 等，或者需要复杂的加密和签名，python-jose 是更好的选择。
  

 
2、使用 python-jose 处理 JWT 

在使用 python-jose 处理 JWT 时，捕获和处理非常是一个重要的环节。
1） 安装 python-jose

起首，确保你已经安装了 python-jose：

1. pip install python-jose

复制代码

2）使用 python-jose 的 JWT 模块

以下是一个使用 python-jose 的 JWT 处理的示例，包罗怎样捕获非常：

1. from jose import jwt, JWTError
2. from jose.exceptions import ExpiredSignatureError
4. # 定义密钥和有效负载
5. secret = 'your-secret-key'
6. payload = {
7.     "user_id": 123,
8.     "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=1)
9. }
11. # 生成 JWT
12. token = jwt.encode(payload, secret, algorithm='HS256')
14. # 解码 JWT 并处理可能的异常
15. try:
16.     decoded = jwt.decode(token, secret, algorithms=['HS256'])
17.     print(decoded)
18. except ExpiredSignatureError:
19.     print("Token has expired")
20. except JWTError:
21.     print("Token is invalid")

复制代码

在处理 python-jose 的 JWT 时，正确地捕获和处理非常是关键。确保你的环境和工具能够正确识别非常类型，将有助于你更好地管理 JWT 错误。
假如我们需要再JWT的playload里面承载更多的信息，可以再claim中声明键值即可，你可以使用 python-jose 和 FastAPI 来实现 JWT 令牌天生操纵。如下所示代码。
使用 FastAPI 和 python-jose 天生 JWT 令牌：

1. from fastapi import FastAPI, Depends, HTTPException, status, Request
2. from fastapi.responses import JSONResponse
3. from jose import JWTError, jwt
4. from datetime import datetime, timedelta
6. app = FastAPI()
8. # 配置项，通常从配置文件中加载
9. JWT_SECRET_KEY = 'your_jwt_secret_key'
10. JWT_ISSUER = 'your_issuer'
11. JWT_AUDIENCE = 'your_audience'
12. JWT_EXPIRED_DAYS = 7
13. ALGORITHM = 'HS256'
15. def generate_token(user_info: dict, role_type: str):
16.     # 获取IP地址
17.     ip = user_info.get('ip', '')
19.     # 定义声明
20.     claims = {
21.         'id': user_info['id'],
22.         'email': user_info['email'],
23.         'name': user_info['name'],
24.         'nickname': user_info.get('nickname', ''),
25.         'phone_number': user_info.get('mobile_phone', ''),
26.         'gender': user_info.get('gender', ''),
27.         'full_name': user_info.get('full_name', ''),
28.         'company_id': user_info.get('company_id', ''),
29.         'company_name': user_info.get('company_name', ''),
30.         'dept_id': user_info.get('dept_id', ''),
31.         'dept_name': user_info.get('dept_name', ''),
32.         'role_type': role_type,
33.         'ip': ip,
34.         'mac_addr': '',  # 无法获得Mac地址
35.         'channel': ''
36.     }
38.     # 定义token过期时间
39.     expiration = datetime.utcnow() + timedelta(days=JWT_EXPIRED_DAYS)
41.     # 创建JWT token
42.     to_encode = {
43.         **claims,
44.         'iss': JWT_ISSUER,
45.         'aud': JWT_AUDIENCE,
46.         'exp': expiration
47.     }
49.     token = jwt.encode(to_encode, JWT_SECRET_KEY, algorithm=ALGORITHM)
50.     return token

复制代码

1. @app.post('/token')
2. async def get_token(request: Request):
3.     # 模拟的用户信息
4.     user_info = {
5.         'id': 123,
6.         'email': 'user@example.com',
7.         'name': 'John Doe',
8.         'nickname': 'Johnny',
9.         'mobile_phone': '123-456-7890',
10.         'gender': 'Male',
11.         'full_name': 'Johnathan Doe',
12.         'company_id': 'ABC123',
13.         'company_name': 'ABC Corp',
14.         'dept_id': 'Dept001',
15.         'dept_name': 'IT',
16.         'ip': request.client.host
17.     }
18.     role_type = 'Admin'
20.     token = generate_token(user_info, role_type)
21.    
22.     headers = {
23.         'access-token': token,
24.         'Authorization': f'Bearer {token}'
25.     }
27.     return JSONResponse(content={'token': token}, headers=headers)
29. if __name__ == "__main__":
30.     import uvicorn
31.     uvicorn.run(app, host="127.0.0.1", port=8000)

复制代码

解释

• FastAPI: 用于构建快速、现代的 Web API。
  
• Request: 从 FastAPI 中导入，用于获取客户端的 IP 地址。
  
• JWT 配置: 使用常量配置 JWT 密钥、发行者、受众、加密算法和逾期时间。
  
• generate_token 函数:
  
  
  
  • 构建 JWT 的 claims，包含用户信息和额外的字段，如 IP 地址、角色类型等。
    
  • 设置 exp 字段定义 JWT 的逾期时间。
    
  • 使用 jwt.encode 创建并签名 JWT。
    
  
  
• get_token 路由:
  
  
  
  • 模拟从请求中获取用户信息（包罗 IP 地址）。
    
  • 调用 generate_token 天生 JWT。
    
  • 将 JWT 放入响应头中，返回给客户端。
    
  
  

 
3、在api中怎样实现AllowAnonymous和验证授权

在 Python 的 FastAPI 框架中，你可以通过以下方式实现雷同于 ASP.NET 中的 AllowAnonymous 和授权验证功能。
1）实现 JWT 授权验证中间件

起首，你需要一个依赖项来检查请求中是否包含有效的 JWT 令牌。假如令牌无效或缺失，依赖项将拒绝请求。通过这种方式，只有标记为“允许匿名”的路由才会跳过验证。
2）安装依赖

确保安装了 python-jose 用于处理 JWT，以及 fastapi：
3） 创建授权依赖

你可以创建一个名为 get_current_user 的依赖项，用于验证 JWT 令牌并提取用户信息。假如没有提供或验证失败，抛出 HTTPException。

1. from fastapi import Depends, HTTPException, status
2. from jose import JWTError, jwt
3. from typing import Optional
5. JWT_SECRET_KEY = 'your_jwt_secret_key'
6. ALGORITHM = 'HS256'
8. def get_current_user(token: str = Depends(oauth2_scheme)):
9.     try:
10.         payload = jwt.decode(token, JWT_SECRET_KEY, algorithms=[ALGORITHM])
11.         user_id: str = payload.get("id")
12.         if user_id is None:
13.             raise HTTPException(
14.                 status_code=status.HTTP_401_UNAUTHORIZED,
15.                 detail="Could not validate credentials",
16.                 headers={"WWW-Authenticate": "Bearer"},
17.             )
18.         return payload
19.     except JWTError:
20.         raise HTTPException(
21.             status_code=status.HTTP_401_UNAUTHORIZED,
22.             detail="Could not validate credentials",
23.             headers={"WWW-Authenticate": "Bearer"},
24.         )

复制代码

get_current_user：用于解析和验证 JWT。假如令牌无效或缺失，会抛出 HTTPException，返回 401 状态码。
详细使用的时候，我们可能把用户信息缓存在Redis里面提高处理效率。
4）实现 AllowAnonymous 功能

在 FastAPI 中，你可以通过 Depends 来实现条件授权。对于需要授权的路由，只需将 get_current_user 作为依赖传递给路由函数。而无需授权的路由，可以直接定义。

1. from fastapi import FastAPI, Depends, HTTPException, status
2. from fastapi.security import OAuth2PasswordBearer
4. app = FastAPI()
6. oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
8. # 允许匿名访问的路由
9. @app.get("/public")
10. def read_public_data():
11.     return {"message": "This is a public endpoint"}
13. # 需要授权的路由
14. @app.get("/protected")
15. def read_protected_data(current_user: dict =<strong> Depends(get_current_user)</strong>):
16.     return {"message": f"Hello, {current_user['name']}"}
18. # 模拟登录生成 JWT 令牌的路由
19. @app.post("/token")
20. def login():
21.     # 这里省略了身份验证过程，只是直接生成一个 JWT 令牌
22.     token = jwt.encode({"id": 1, "name": "John Doe"}, JWT_SECRET_KEY, algorithm=ALGORITHM)
23.     return {"access_token": token, "token_type": "bearer"}

复制代码

• 公共路由 (/public)：可以直接访问，不需要任何身份验证。
  
• 受保护路由 (/protected)：必须提供有效的 JWT 令牌才能访问。
  
• 登录路由 (/token)：天生一个 JWT 令牌，可以用于受保护的路
  

Depends(get_current_user)：在需要保护的路由中，通过依赖项注入 get_current_user，确保只有通过身份验证的用户才能访问。
在 FastAPI 中，建议通过依赖项注入（Depends）来获取当前用户的信息，而不是直接访问 request.user。这种方式更加灵活而且与 FastAPI 的设计哲学更同等。
在详细项目中，我们为了方便，每每通过中间件的方式进行定义和处理授权的过程。

通过authentiate函数处理验证用户令牌的有效性。

 我们一般再main.py入口中加入中间件的处理即可。

1.     # JWT auth, required
2.     app.add_middleware(
3.         AuthenticationMiddleware,
4.         backend=JwtAuthMiddleware(),
5.         on_error=JwtAuthMiddleware.auth_exception_handler,
6.     )

复制代码

 
4、一些错误处理

当你在解码 JWT 时遇到 "Invalid audience" 错误，通常意味着在天生或解码 JWT 时，aud (audience) 声明没有正确设置或验证。以下是办理这个问题的步调和阐明：
1） 明白 aud (Audience) 声明

• aud 是 JWT 中的一个可选声明，通常用于指定 JWT 的接收者（受众）。在解码 JWT 时，jwt.decode 会检查这个声明是否与预期的值匹配。
  

设置和检查 aud 声明，天生 Token 时设置 aud
 
假如你盼望 JWT 包含 aud 声明，可以在天生 token 时传递它。例如：

1. to_encode = {
2.     "sub": "user_id",
3.     "aud": "your_audience",  # 设置aud声明
4.     "exp": datetime.utcnow() + timedelta(minutes=30)
5. }
7. token = jwt.encode(to_encode, settings.TOKEN_SECRET_KEY, algorithm=settings.TOKEN_ALGORITHM)

复制代码

解码 Token 时验证 aud
在解码 JWT 时，指定 audience 参数以匹配天生时的 aud：

1. try:
2.     payload = jwt.decode(
3.         token,
4.         settings.TOKEN_SECRET_KEY,
5.         algorithms=[settings.TOKEN_ALGORITHM],
6.         audience="your_audience"  # 验证aud声明
7.     )
8.     print(f"Decoded payload: {payload}")
9. except JWTError as e:
10.     print(f"Token decode failed: {e}")

复制代码

2）Token decode failed: Subject must be a string.

"Token decode failed: Subject must be a string" 错误通常是由于 sub (subject) 声明的值不是字符串引起的。sub 是 JWT 中常用的一个声明，用来标识 token 的主体，好比用户 ID 或用户名。JWT 标准要求 sub 的值必须是字符串。
检查 sub 声明的值
起首，确保在天生 token 时，sub 声明的值是一个字符串：

1. to_encode = {
2.     "sub": str(user_id),  # 确保 user_id 是字符串
3.     "aud": "your_audience",  # 其他字段
4.     "exp": datetime.utcnow() + timedelta(minutes=30)
5. }
7. token = jwt.encode(to_encode, settings.TOKEN_SECRET_KEY, algorithm=settings.TOKEN_ALGORITHM)

复制代码

假如 sub 的值是一个非字符串类型（如整数或其他对象），请将其转换为字符串：

1. user_id = 123  # 假设 user_id 是一个整数
2. to_encode = {
3.     "sub": str(user_id),  # 将 user_id 转换为字符串
4.     "aud": "your_audience",
5.     "exp": datetime.utcnow() + timedelta(minutes=30)
6. }
8. token = jwt.encode(to_encode, settings.TOKEN_SECRET_KEY, algorithm=settings.TOKEN_ALGORITHM)

复制代码

 
3）schema怎样移除敏感字段

在处理数据模型和模式（schema）时，特别是当涉及到敏感信息（如暗码、身份信息等）时，偶然需要从输出或序列化结果中移除这些敏感字段。根据你使用的库或框架，处理敏感字段的方法会有所不同。以下是一些常见的方法来移除敏感字段：
使用 Pydantic 的 exclude 参数
假如你在使用 Pydantic（例如在 FastAPI 中），你可以使用模型的 dict 方法的 exclude 参数来清除敏感字段。

1. from pydantic import BaseModel
3. class User(BaseModel):
4.     username: str
5.     email: str
6.     password: str  # 敏感字段
8. user = User(username="user1", email="user1@example.com", password="secret")
10. # 创建一个不包含敏感字段的字典
11. user_dict = user.dict(exclude={"password"})
13. print(user_dict)

复制代码

使用 SQLAlchemy 的 __mapper_args__
假如你使用 SQLAlchemy 而且盼望从序列化结果中清除敏感字段，可以使用模型的 __mapper_args__ 进行配置。例如：

1. from sqlalchemy import Column, String
2. from sqlalchemy.ext.declarative import declarative_base
4. Base = declarative_base()
6. class User(Base):
7.     __tablename__ = 'users'
9.     id = Column(String, primary_key=True)
10.     username = Column(String)
11.     email = Column(String)
12.     password = Column(String)  # 敏感字段
14.     def to_dict(self):
15.         # 移除敏感字段
16.         return {c.name: getattr(self, c.name) for c in self.__table__.columns if c.name != 'password'}
18. user = User(id="1", username="user1", email="user1@example.com", password="secret")
19. print(user.to_dict())

复制代码

自定义序列化方法
假如你使用自定义模型或类，而且没有使用特定的库，你可以实现自定义序列化方法来清除敏感字段。

1. class User:
2.     def __init__(self, username, email, password):
3.         self.username = username
4.         self.email = email
5.         self.password = password  # 敏感字段
7.     def to_dict(self):
8.         # 移除敏感字段
9.         return {
10.             "username": self.username,
11.             "email": self.email
12.         }
14. user = User(username="user1", email="user1@example.com", password="secret")
15. print(user.to_dict())

复制代码

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4