Comment implémenter le cryptage et le déchiffrement des données demandées dans FastAPI

Comment implémenter le cryptage et le déchiffrement des données demandées dans FastAPI

Introduction :
FastAPI est un framework Web hautes performances basé sur Python, qui fournit un moyen concis et rapide de créer des applications Web. Au cours du processus de développement, nous devons souvent crypter et déchiffrer les données demandées pour garantir la sécurité de la transmission des données. Cet article présentera comment implémenter le cryptage et le déchiffrement des données demandées dans FastAPI et fournira des exemples de code correspondants.

Étape 1 : Installer les dépendances requises
Avant de commencer, nous devons installer certaines dépendances nécessaires. Utilisez pip pour installer les packages de dépendances requis via la commande suivante :

pip install cryptography

Étape 2 : Générer une clé
Les clés sont requises pour les processus de cryptage et de déchiffrement. Dans l'exemple, nous utilisons l'algorithme AES pour le cryptage et le déchiffrement. Tout d’abord, nous devons générer une clé. Vous pouvez utiliser le code suivant pour générer une nouvelle clé :

from cryptography.fernet import Fernet

def generate_key():
    key = Fernet.generate_key()
    with open("key.key", "wb") as key_file:
        key_file.write(key)

Après avoir exécuté le code ci-dessus, un fichier nommé "key.key" sera généré dans le répertoire courant, qui enregistre la clé générée.

Étape 3 : Chiffrer les données de la requête
Dans FastAPI, un middleware peut être utilisé pour implémenter le cryptage des données de la requête. Voici le code d'un exemple de middleware :

from fastapi import FastAPI, Request

app = FastAPI()

@app.middleware("http")
async def encrypt_request_data(request: Request, call_next):
    # 读取密钥
    with open("key.key", "rb") as key_file:
        key = key_file.read()
    
    # 获取请求数据
    data = await request.body()
    
    # 加密数据
    f = Fernet(key)
    encrypted_data = f.encrypt(data)
    
    # 更新请求数据
    request._body = encrypted_data
    
    # 继续处理请求
    response = await call_next(request)
    
    return response

Dans le code ci-dessus, nous lisons d'abord la clé générée précédemment. Utilisez ensuite la classe Fernet pour effectuer des opérations de chiffrement. En appelant la méthode encrypt, nous pouvons chiffrer les données demandées. Enfin, mettez à jour les données demandées et poursuivez le traitement de la demande. encrypt方法，我们可以将请求的数据加密。最后，更新请求的数据，并继续处理请求。

步骤4：解密请求数据
在处理加密的请求数据之前，我们需要解密它们。以下是一个示例中间件的代码：

@app.middleware("http")
async def decrypt_request_data(request: Request, call_next):
    # 读取密钥
    with open("key.key", "rb") as key_file:
        key = key_file.read()
    
    # 获取请求数据
    data = await request.body()
    
    # 解密数据
    f = Fernet(key)
    decrypted_data = f.decrypt(data)
    
    # 更新请求数据
    request._body = decrypted_data
    
    # 继续处理请求
    response = await call_next(request)
    
    return response

与加密过程类似，我们首先读取密钥，然后使用Fernet类进行解密操作。通过调用decrypt方法，我们可以将加密的请求数据解密。最后，更新请求的数据，并继续处理请求。

步骤5：测试加密和解密过程
使用上述代码实现了加密和解密中间件后，我们需要测试一下是否能够正常加密和解密请求数据。以下是一个快速测试的代码示例：

from fastapi import FastAPI

app = FastAPI(debug=True)

@app.post("/api/encrypt")
async def encrypt_data(data: str):
    return {"encrypted_data": data}

@app.post("/api/decrypt")
async def decrypt_data(data: str):
    return {"decrypted_data": data}

在上述代码中，我们添加了两个路由，分别用于接收加密和解密的请求。这两个路由接收一个名为data

Étape 4 : Décrypter les données de la demande

Avant de traiter les données de la demande cryptées, nous devons les décrypter. Voici le code d'un exemple de middleware :
rrreee

Semblable au processus de cryptage, nous lisons d'abord la clé puis utilisons la classe Fernet pour effectuer l'opération de décryptage. En appelant la méthode decrypt, nous pouvons décrypter les données de requête chiffrées. Enfin, mettez à jour les données demandées et poursuivez le traitement de la demande.

Étape 5 : Tester le processus de cryptage et de décryptage

Après avoir utilisé le code ci-dessus pour implémenter le middleware de cryptage et de décryptage, nous devons tester si les données de la demande peuvent être cryptées et déchiffrées normalement. Voici un exemple de code pour un test rapide :
• rrreee
Dans le code ci-dessus, nous avons ajouté deux routes pour recevoir respectivement les requêtes cryptées et décryptées. Ces deux routes reçoivent un paramètre de chaîne nommé data et renvoient respectivement des données chiffrées et déchiffrées. Cet exemple est uniquement destiné à des fins de démonstration. Les projets réels doivent être traités en conséquence en fonction des besoins de l'entreprise.
• Conclusion :

Grâce aux étapes ci-dessus, nous avons mis en œuvre avec succès le processus de cryptage et de déchiffrement des données de demande dans FastAPI. En utilisant un middleware de chiffrement, nous pouvons garantir la sécurité lors de la transmission des données. Le processus de cryptage et de décryptage peut être modifié et étendu en fonction des besoins réels. J'espère que cet article vous aidera à implémenter le cryptage et le déchiffrement des données dans le développement FastAPI. 🎜🎜Matériaux de référence : 🎜🎜🎜[Document officiel FastAPI](https://fastapi.tiangolo.com/)🎜🎜[Document officiel de cryptographie](https://cryptography.io/en/latest/)🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!