python如何给数字加密

Python中给数字加密的常用方法有：对称加密（如AES）、非对称加密（如RSA）、哈希算法（如SHA-256）。其中，对称加密被广泛应用于需要高效加密解密的场景。

对称加密是一种使用相同密钥进行加密和解密的技术。AES（Advanced Encryption Standard）是对称加密算法中最常用的一种。它拥有较高的安全性和加密速度，适合处理较大数据量的加密需求。使用AES加密时，首先需要一个密钥和一个初始向量（IV），然后通过这些参数对数据进行加密。密钥和IV的选择至关重要，直接影响到加密的安全性。常见的AES模式包括ECB（电子密码本）、CBC（密码分组链接）、CFB（密码反馈）等，其中CBC模式因其安全性较高而被广泛使用。

一、对称加密

1. AES加密

AES（Advanced Encryption Standard）是一种广泛使用的对称加密算法，具有较高的安全性和效率。它的核心思想是通过一个固定长度的密钥来加密和解密数据。AES支持128位、192位和256位密钥长度，通常情况下，256位密钥被认为是最安全的选择。

在使用AES加密时，需要注意以下几点：

密钥的选择：密钥的长度和复杂性直接影响AES加密的安全性。建议使用随机生成的密钥，并确保其保密性。
初始向量（IV）的使用：IV是一个用于初始化加密过程的随机数，它增加了加密的随机性和安全性。通常，IV的长度与密钥长度相同。
加密模式的选择：AES支持多种加密模式，如ECB、CBC、CFB、OFB等。不同模式有不同的安全特性，其中CBC模式被认为是最安全的选择之一。

以下是一个使用Python实现AES加密的示例代码：

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes
def encrypt_aes(data, key):
    iv = get_random_bytes(16)  # 生成随机IV
    cipher = AES.new(key, AES.MODE_CBC, iv)
    encrypted_data = cipher.encrypt(pad(data, AES.block_size))
    return iv + encrypted_data
def decrypt_aes(encrypted_data, key):
    iv = encrypted_data[:16]
    cipher = AES.new(key, AES.MODE_CBC, iv)
    decrypted_data = unpad(cipher.decrypt(encrypted_data[16:]), AES.block_size)
    return decrypted_data
key = get_random_bytes(16)  # 生成随机密钥
data = b"Sensitive data that needs encryption"
encrypted = encrypt_aes(data, key)
decrypted = decrypt_aes(encrypted, key)
print(f"Original: {data}")
print(f"Encrypted: {encrypted}")
print(f"Decrypted: {decrypted}")

2. DES加密

DES（Data Encryption Standard）是一种较早的对称加密算法，相较于AES，DES的密钥长度较短（56位），因此安全性较低。尽管如此，DES仍然在一些特定场景下被使用。

在Python中，可以使用pycryptodome库实现DES加密。以下是一个简单的示例：

from Crypto.Cipher import DES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes
def encrypt_des(data, key):
    cipher = DES.new(key, DES.MODE_ECB)
    encrypted_data = cipher.encrypt(pad(data, DES.block_size))
    return encrypted_data
def decrypt_des(encrypted_data, key):
    cipher = DES.new(key, DES.MODE_ECB)
    decrypted_data = unpad(cipher.decrypt(encrypted_data), DES.block_size)
    return decrypted_data
key = get_random_bytes(8)  # 生成随机密钥
data = b"Data to encrypt"
encrypted = encrypt_des(data, key)
decrypted = decrypt_des(encrypted, key)
print(f"Original: {data}")
print(f"Encrypted: {encrypted}")
print(f"Decrypted: {decrypted}")

二、非对称加密

1. RSA加密

RSA（Rivest–Shamir–Adleman）是一种广泛使用的非对称加密算法，它利用一对密钥（公钥和私钥）进行加密和解密。非对称加密的特点是，公钥用于加密，私钥用于解密，这使得RSA非常适合用于数据传输中的加密。

在Python中，可以使用pycryptodome库实现RSA加密。以下是一个简单的示例：

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
def generate_rsa_keys():
    key = RSA.generate(2048)
    private_key = key.export_key()
    public_key = key.publickey().export_key()
    return private_key, public_key
def encrypt_rsa(data, public_key):
    cipher = PKCS1_OAEP.new(RSA.import_key(public_key))
    encrypted_data = cipher.encrypt(data)
    return encrypted_data
def decrypt_rsa(encrypted_data, private_key):
    cipher = PKCS1_OAEP.new(RSA.import_key(private_key))
    decrypted_data = cipher.decrypt(encrypted_data)
    return decrypted_data
private_key, public_key = generate_rsa_keys()
data = b"Sensitive data"
encrypted = encrypt_rsa(data, public_key)
decrypted = decrypt_rsa(encrypted, private_key)
print(f"Original: {data}")
print(f"Encrypted: {encrypted}")
print(f"Decrypted: {decrypted}")

2. ECC加密

ECC（Elliptic Curve Cryptography）是一种基于椭圆曲线数学原理的非对称加密算法。与RSA相比，ECC在相同的安全级别下使用的密钥长度更短，因此加密速度更快，资源消耗更少。

在Python中，可以使用ecdsa库实现ECC加密。以下是一个简单的示例：

from ecdsa import SigningKey, NIST384p
from hashlib import sha256
def generate_ecc_keys():
    private_key = SigningKey.generate(curve=NIST384p)
    public_key = private_key.verifying_key
    return private_key, public_key
def sign_data(data, private_key):
    signature = private_key.sign(data, hashfunc=sha256)
    return signature
def verify_signature(data, signature, public_key):
    return public_key.verify(signature, data, hashfunc=sha256)
private_key, public_key = generate_ecc_keys()
data = b"Data to sign"
signature = sign_data(data, private_key)
is_verified = verify_signature(data, signature, public_key)
print(f"Data: {data}")
print(f"Signature: {signature}")
print(f"Verified: {is_verified}")

三、哈希算法

1. SHA-256

SHA-256（Secure Hash Algorithm 256-bit）是一种广泛使用的哈希算法，用于生成数据的固定长度哈希值。与加密不同，哈希算法是不可逆的，常用于数据完整性验证。

在Python中，可以使用hashlib库实现SHA-256哈希。以下是一个简单的示例：

import hashlib
def hash_sha256(data):
    sha256_hash = hashlib.sha256()
    sha256_hash.update(data)
    return sha256_hash.hexdigest()
data = b"Data to hash"
hashed_data = hash_sha256(data)
print(f"Original: {data}")
print(f"Hashed: {hashed_data}")

2. MD5

MD5（Message-Digest Algorithm 5）是一种较早的哈希算法，生成128位哈希值。尽管MD5在速度和资源消耗方面表现良好，但由于其安全性较低，已不推荐用于安全性要求较高的场景。

在Python中，可以使用hashlib库实现MD5哈希。以下是一个简单的示例：

import hashlib
def hash_md5(data):
    md5_hash = hashlib.md5()
    md5_hash.update(data)
    return md5_hash.hexdigest()
data = b"Data to hash"
hashed_data = hash_md5(data)
print(f"Original: {data}")
print(f"Hashed: {hashed_data}")

四、综合应用场景

在实际应用中，通常会结合使用多种加密和哈希算法，以达到更高的安全性。例如，可以使用RSA加密传输对称加密的密钥，然后使用AES对称加密数据。同时，使用SHA-256哈希算法来验证数据的完整性。

1. 数据加密传输

在数据传输过程中，通常会使用非对称加密算法（如RSA）加密对称密钥，然后使用对称加密算法（如AES）加密实际数据。接收方使用私钥解密对称密钥，然后使用该密钥解密数据。

以下是一个示例代码，展示如何在Python中实现这一流程：

from Crypto.Cipher import AES, PKCS1_OAEP
from Crypto.PublicKey import RSA
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes
def encrypt_data(data, public_key):
    # 生成随机对称密钥
    sym_key = get_random_bytes(16)
    # 使用RSA加密对称密钥
    rsa_cipher = PKCS1_OAEP.new(RSA.import_key(public_key))
    encrypted_sym_key = rsa_cipher.encrypt(sym_key)
    # 使用AES加密数据
    iv = get_random_bytes(16)
    aes_cipher = AES.new(sym_key, AES.MODE_CBC, iv)
    encrypted_data = aes_cipher.encrypt(pad(data, AES.block_size))
    return encrypted_sym_key, iv + encrypted_data
def decrypt_data(encrypted_sym_key, encrypted_data, private_key):
    # 使用RSA解密对称密钥
    rsa_cipher = PKCS1_OAEP.new(RSA.import_key(private_key))
    sym_key = rsa_cipher.decrypt(encrypted_sym_key)
    # 使用AES解密数据
    iv = encrypted_data[:16]
    aes_cipher = AES.new(sym_key, AES.MODE_CBC, iv)
    decrypted_data = unpad(aes_cipher.decrypt(encrypted_data[16:]), AES.block_size)
    return decrypted_data
生成RSA密钥对
key = RSA.generate(2048)
private_key = key.export_key()
public_key = key.publickey().export_key()
data = b"Secure data transfer"
encrypted_sym_key, encrypted_data = encrypt_data(data, public_key)
decrypted_data = decrypt_data(encrypted_sym_key, encrypted_data, private_key)
print(f"Original: {data}")
print(f"Decrypted: {decrypted_data}")

2. 数据完整性验证

在数据传输或存储过程中，可以使用哈希算法（如SHA-256）生成数据的哈希值，以便在接收或读取时验证数据的完整性。

以下是一个示例代码，展示如何在Python中实现数据完整性验证：

import hashlib
def hash_data(data):
    sha256_hash = hashlib.sha256()
    sha256_hash.update(data)
    return sha256_hash.hexdigest()
def verify_data(data, expected_hash):
    actual_hash = hash_data(data)
    return actual_hash == expected_hash
data = b"Important data"
data_hash = hash_data(data)
模拟数据传输或存储
received_data = data  # 假设数据未被篡改
is_valid = verify_data(received_data, data_hash)
print(f"Data: {received_data}")
print(f"Hash: {data_hash}")
print(f"Is data valid: {is_valid}")