Bagaimana untuk menyulitkan dan menyahsulit data dalam Python

Bagaimana untuk menyulitkan dan menyahsulit data dalam Python, contoh kod khusus diperlukan

Penyulitan dan penyahsulitan data adalah konsep yang sangat penting dalam bidang keselamatan maklumat. Dalam aplikasi praktikal, kami selalunya perlu menyulitkan data sensitif untuk mengelakkan akses tanpa kebenaran dan kebocoran maklumat. Python ialah bahasa pengaturcaraan berkuasa yang menyediakan banyak perpustakaan dan fungsi untuk melaksanakan operasi penyulitan dan penyahsulitan data. Artikel ini akan memperkenalkan beberapa algoritma penyulitan yang biasa digunakan dan contoh kod khusus untuk melaksanakan penyulitan dan penyahsulitan data dalam Python.

1. Algoritma penyulitan MD5

MD5 (Message-Digest Algorithm 5) ialah fungsi cincang yang biasa digunakan untuk menyulitkan data dalam sebarang panjang. Ia menukarkan mesej dari sebarang panjang kepada cap jari digital 128-bit untuk memastikan integriti data dan tidak boleh diubah suai.

Dalam Python, kita boleh menggunakan perpustakaan hashlib untuk melaksanakan algoritma penyulitan MD5. Berikut ialah contoh kod:

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)

Hasil berjalan:

加密后的数据： 5eb63bbbe01eeed093cb22bb8f5acdc3

2. Algoritma penyulitan AES

AES (Advanced Encryption Standard) ialah standard penyulitan lanjutan yang digunakan secara meluas dalam pelbagai senario penyulitan. Ia menggunakan penyulitan kunci simetri untuk melaksanakan operasi penyulitan dan penyahsulitan yang pantas dan selamat pada data.

Dalam Python, kita boleh menggunakan perpustakaan pycryptodome untuk melaksanakan algoritma penyulitan AES. Berikut ialah contoh kod:

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)

Hasil operasi:

解密后的数据： hello world

3. Algoritma penyulitan RSA

RSA (Rivest-Shamir-Adleman) ialah algoritma penyulitan asimetri yang biasa digunakan untuk penyulitan data dan tandatangan digital. Ia menggunakan dua kekunci, kunci awam digunakan untuk menyulitkan data dan kunci peribadi digunakan untuk menyahsulit data.

Dalam Python, kita boleh menggunakan perpustakaan kriptografi untuk melaksanakan algoritma penyulitan RSA. Berikut ialah contoh kod:

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)

Hasil berjalan:

解密后的数据： hello world

Melalui contoh kod di atas, kita boleh melihat cara menggunakan algoritma penyulitan yang berbeza untuk menyulitkan dan menyahsulit data dalam Python. Memilih algoritma penyulitan dan panjang kunci yang sesuai, dan mengikuti amalan pengekodan selamat, akan memastikan kerahsiaan dan integriti data. Sila ambil perhatian bahawa kod sampel dalam artikel ini adalah untuk rujukan sahaja Dalam aplikasi sebenar, butiran seperti pengurusan kunci dan keselamatan penghantaran data perlu dipertimbangkan.

Atas ialah kandungan terperinci Bagaimana untuk menyulitkan dan menyahsulit data dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!