create_access_token创建token怎么设置token时间

要设置访问令牌（access token）的过期时间，你需要使用`datetime`模块来计算过期时间。下面是一个示例代码，展示了如何使用 Python 设置过期时间为 1 小时：

from datetime import datetime, timedelta

# 设置令牌过期时间为 1 小时
expire_time = datetime.now() + timedelta(hours=1)

# 格式化过期时间为字符串（以便存储或传输）
token_expiration = expire_time.strftime("%Y-%m-%d %H:%M:%S")

# 这里可以将 token_expiration 存储在数据库或在生成的令牌中返回给客户端

在这个示例中，我们使用`datetime.now()`获取当前时间，并使用`timedelta(hours=1)`来计算出一个小时后的时间点。然后，我们使用`.strftime()`方法将过期时间格式化为字符串。

你可以根据自己的需求调整过期时间的长度。在实际应用中，你可能需要将过期时间存储在数据库中，或者将其包含在生成的令牌中返回给客户端。

相关问题

create_access_token，并没有algorithm和private_key参数啊

非常抱歉，我犯了一个错误。在 Flask-JWT-Extended 中，使用非对称加密时，确实不能将算法和私钥作为参数传递给 `create_access_token()` 函数。正确的做法是，需要在 Flask-JWT-Extended 的配置中指定使用的算法和密钥。下面是修改后的代码：

from flask import Flask
from flask_jwt_extended import JWTManager, jwt_required, create_access_token, get_jwt_identity
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa

app = Flask(__name__)
app.config['JWT_SECRET_KEY'] = 'super-secret'
app.config['JWT_ALGORITHM'] = 'RS256'   # 指定算法为 RS256
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)
public_key = private_key.public_key()
app.config['JWT_PRIVATE_KEY'] = private_key   # 指定私钥
app.config['JWT_PUBLIC_KEY'] = public_key    # 指定公钥
jwt = JWTManager(app)

@app.route('/login', methods=['POST'])
def login():
    # 获取用户信息
    username = request.json.get('username', None)
    password = request.json.get('password', None)

    # 验证用户信息（这里省略具体实现）
    if username != 'user' or password != 'pass':
        return {'msg': '用户名或密码错误'}, 401

    # 生成 access token
    access_token = create_access_token(identity=username)

    return {'access_token': access_token}, 200

@app.route('/protected', methods=['GET'])
@jwt_required()
def protected():
    # 获取当前用户身份信息
    current_user = get_jwt_identity()

    return {'msg': f'Hello, {current_user}!'}, 200

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

非常感谢您的指正，我会更加认真地检查代码的准确性。

create_access_token并没有algorithm和private_key这2个参数啊

非常抱歉，我犯了一个错误。确实，`create_access_token`函数没有`algorithm`和`private_key`这两个参数，因为`flask_jwt_extended`库默认使用HS256算法进行JWT签名和验证，所以我们需要先更改默认算法并添加我们自己的密钥。

下面是一个使用RSA非对称加密的示例：

1. 安装所需的依赖

pip install flask flask_jwt_extended cryptography

2. 生成RSA密钥对

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization

private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)

public_key = private_key.public_key()

# 保存私钥
with open('private_key.pem', 'wb') as f:
    f.write(private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    ))

# 保存公钥
with open('public_key.pem', 'wb') as f:
    f.write(public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    ))

3. 更改默认的JWT算法和密钥

from flask import Flask
from flask_jwt_extended import JWTManager
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend

app = Flask(__name__)
app.config['JWT_SECRET_KEY'] = 'super-secret'  # 这个密钥不用于签名，只用于加密
app.config['JWT_ALGORITHM'] = 'RS256'

jwt = JWTManager(app)

# 加载RSA密钥
with open('private_key.pem', 'rb') as f:
    private_key = serialization.load_pem_private_key(
        f.read(),
        password=None,
        backend=default_backend()
    )

with open('public_key.pem', 'rb') as f:
    public_key = serialization.load_pem_public_key(
        f.read(),
        backend=default_backend()
    )

# 设置JWT密钥和算法
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
    jti = decrypted_token['jti']
    return jti in blacklist

@jwt.user_identity_loader
def user_identity_lookup(user):
    return user.id

@jwt.user_loader_callback_loader
def user_loader_callback(identity):
    return User.query.get(identity)

@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
    jti = decrypted_token['jti']
    return jti in blacklist

@jwt.additional_claims_loader
def add_claims_to_access_token(identity):
    return {
        'foo': 'bar'
    }

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

在这个示例中，我们使用RSA非对称加密算法来对JWT进行签名和验证。在加载RSA密钥时，我们使用`cryptography`库来读取PEM格式的密钥文件并转换为`cryptography`库可以使用的密钥对象。然后，我们使用`@jwt.token_in_blacklist_loader`装饰器来添加一个回调函数，以便我们可以在Token黑名单中检查Token是否存在。我们还使用`@jwt.user_identity_loader`和`@jwt.user_loader_callback_loader`装饰器来指定用户的身份和用户回调函数。最后，我们使用`@jwt.additional_claims_loader`装饰器来添加自定义的JWT声明。