Comment crypter et décrypter des données en Python

Comment crypter et déchiffrer des données en Python, des exemples de code spécifiques sont nécessaires

Le cryptage et le décryptage des données sont des concepts très importants dans le domaine de la sécurité de l'information. Dans les applications pratiques, nous devons souvent chiffrer des données sensibles pour empêcher tout accès non autorisé et toute fuite d’informations. Python est un langage de programmation puissant qui fournit une multitude de bibliothèques et de fonctions pour mettre en œuvre des opérations de cryptage et de décryptage de données. Cet article présentera certains algorithmes de chiffrement couramment utilisés et des exemples de code spécifiques pour implémenter le chiffrement et le déchiffrement des données en Python.

1. Algorithme de cryptage MD5

MD5 (Message-Digest Algorithm 5) est une fonction de hachage couramment utilisée pour crypter des données de n'importe quelle longueur. Il convertit les messages de n'importe quelle longueur en une empreinte numérique de 128 bits pour garantir l'intégrité et l'inviolabilité des données.

En Python, nous pouvons utiliser la bibliothèque hashlib pour implémenter l'algorithme de chiffrement MD5. Voici un exemple de code :

import hashlib

def md5_encrypt(data):
    md5 = hashlib.md5()
    md5.update(data.encode(encoding='utf-8'))
    encrypt_data = md5.hexdigest()
    return encrypt_data

# 测试示例
data = 'hello world'
encrypted_data = md5_encrypt(data)
print("加密后的数据：", encrypted_data)

Résultats d'exécution :

加密后的数据： 5eb63bbbe01eeed093cb22bb8f5acdc3

2. Algorithme de cryptage AES

AES (Advanced Encryption Standard) est une norme de cryptage avancée largement utilisée dans divers scénarios de cryptage. Il utilise un cryptage à clé symétrique pour effectuer des opérations de cryptage et de déchiffrement rapides et sécurisées sur les données.

En Python, nous pouvons utiliser la bibliothèque pycryptodome pour implémenter l'algorithme de chiffrement AES. Voici un exemple de code :

from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes

def aes_encrypt(data, key):
    cipher = AES.new(key, AES.MODE_EAX)
    nonce = cipher.nonce
    ciphertext, tag = cipher.encrypt_and_digest(data.encode())
    encrypted_data = nonce + ciphertext + tag
    return encrypted_data

def aes_decrypt(encrypted_data, key):
    nonce = encrypted_data[:16]
    ciphertext = encrypted_data[16:-16]
    tag = encrypted_data[-16:]
    cipher = AES.new(key, AES.MODE_EAX, nonce=nonce)
    data = cipher.decrypt_and_verify(ciphertext, tag)
    return data.decode()

# 测试示例
data = 'hello world'
key = get_random_bytes(16)
encrypted_data = aes_encrypt(data, key)
print("加密后的数据：", encrypted_data)
decrypted_data = aes_decrypt(encrypted_data, key)
print("解密后的数据：", decrypted_data)

Résultats d'exploitation :

解密后的数据： hello world

3. Algorithme de cryptage RSA

RSA (Rivest-Shamir-Adleman) est un algorithme de cryptage asymétrique couramment utilisé pour le cryptage des données et les signatures numériques. Il utilise deux clés, la clé publique est utilisée pour crypter les données et la clé privée est utilisée pour déchiffrer les données.

En Python, nous pouvons utiliser la bibliothèque de cryptographie pour implémenter l'algorithme de chiffrement RSA. Voici un exemple de code :

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

def rsa_encrypt(data, public_key):
    public_key = serialization.load_pem_public_key(public_key, backend=default_backend())
    encrypted_data = public_key.encrypt(data.encode(), padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))
    return encrypted_data

def rsa_decrypt(encrypted_data, private_key):
    private_key = serialization.load_pem_private_key(private_key, password=None, backend=default_backend())
    decrypted_data = private_key.decrypt(encrypted_data, padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None))
    return decrypted_data.decode()

# 测试示例
data = 'hello world'
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048, backend=default_backend())
private_pem = private_key.private_bytes(encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=serialization.NoEncryption())
public_key = private_key.public_key()
public_pem = public_key.public_bytes(encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo)
encrypted_data = rsa_encrypt(data, public_pem)
print("加密后的数据：", encrypted_data)
decrypted_data = rsa_decrypt(encrypted_data, private_pem)
print("解密后的数据：", decrypted_data)

Résultat d'exécution :

解密后的数据： hello world

Grâce à l'exemple de code ci-dessus, nous pouvons voir comment utiliser différents algorithmes de cryptage pour crypter et déchiffrer des données en Python. Le choix d'un algorithme de chiffrement et d'une longueur de clé appropriés, ainsi que le respect de pratiques de codage sécurisées, garantiront la confidentialité et l'intégrité des données. Veuillez noter que l'exemple de code présenté dans cet article est uniquement à titre de référence. Dans l'application réelle, des détails tels que la gestion des clés et la sécurité de la transmission des données doivent être pris en compte.

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!