cryptography，是一个强大的 Python 库

cryptography 是一个强大的 Python 库，提供了加密、解密、签名、验证等一系列安全功能，帮助开发者轻松实现数据安全。该库适用于各种加密需求，从简单的数据加密到复杂的网络安全通信。

cryptography的功能特性

• 安全性：提供多种加密算法，确保数据安全。
• 灵活性：支持多种加密协议和标准。
• 性能：优化算法，提高加密解密速度。
• 跨平台：可在多种操作系统上运行。
• 易用性：简洁的 API 设计，易于学习和使用。

如何安装或者引入 cryptography

使用 pip 命令安装 cryptography 库：

pip install cryptography

在 Python 代码中引入 cryptography 库：

from cryptography.fernet import Fernet

cryptography的基本功能

对称加密

使用 Fernet 算法进行对称加密。

from cryptography.fernet import Fernet

# 生成密钥
key = Fernet.generate_key()

# 实例化 Fernet 对象
cipher_suite = Fernet(key)

# 加密数据
data = b"Hello, World!"
encrypted_data = cipher_suite.encrypt(data)

# 解密数据
decrypted_data = cipher_suite.decrypt(encrypted_data)

print(encrypted_data)  # 输出加密后的数据
print(decrypted_data)  # 输出解密后的数据

非对称加密

使用 RSA 算法进行非对称加密。

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

# 生成公钥和私钥
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)
public_key = private_key.public_key()

# 加密数据
data = b"Hello, World!"
encrypted_data = public_key.encrypt(
    data,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# 解密数据
decrypted_data = private_key.decrypt(
    encrypted_data,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

print(encrypted_data)  # 输出加密后的数据
print(decrypted_data)  # 输出解密后的数据

哈希算法

使用 SHA-256 算法进行哈希计算。

from cryptography.hazmat.primitives import hashes

# 计算哈希值
data = b"Hello, World!"
hasher = hashes.Hash(hashes.SHA256())
hasher.update(data)
hash_value = hasher.finalize()

print(hash_value)  # 输出哈希值

cryptography的高级功能

对称加密

在对称加密中，cryptography 提供了多种算法，如 AES、ChaCha20 等。以下是一个使用 AES 算法进行加密和解密的示例：

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import padding

# 生成密钥和初始化向量
key = b'your-encryption-key-here'
iv = b'your-iv-here'

# 创建加密器实例
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())

# 填充数据以满足加密算法的块大小要求
padder = padding.PKCS7(128).padder()
data = b'your-data-here'
padded_data = padder.update(data) + padder.finalize()

# 加密数据
encryptor = cipher.encryptor()
encrypted_data = encryptor.update(padded_data) + encryptor.finalize()

# 解密数据
decryptor = cipher.decryptor()
unpadded_data = decryptor.update(encrypted_data) + decryptor.finalize()

# 移除填充
unpadder = padding.PKCS7(128).unpadder()
data = unpadder.update(unpadded_data) + unpadder.finalize()

非对称加密

非对称加密算法，如 RSA、ECDSA 等，允许公钥加密和私钥解密，或私钥签名和公钥验证。以下是一个使用 RSA 算法进行加密和解密的示例：

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives.asymmetric import padding

# 生成公钥和私钥
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend()
)
public_key = private_key.public_key()

# 加密数据
encrypted_data = public_key.encrypt(
    b'your-data-here',
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# 解密数据
decrypted_data = private_key.decrypt(
    encrypted_data,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

数字签名

数字签名用于验证消息的完整性和来源。以下是一个使用 ECDSA 算法进行签名的示例：

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives.asymmetric import padding

# 生成公钥和私钥
private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
public_key = private_key.public_key()

# 签名数据
signature = private_key.sign(
    b'your-data-here',
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)

# 验证签名
try:
    public_key.verify(
        signature,
        b'your-data-here',
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("The signature is valid.")
except Exception as e:
    print("The signature is invalid.")

会话密钥交换

密钥交换协议，如 Diffie-Hellman，允许双方在不安全的通道上安全地交换密钥。以下是一个使用 X25519 算法进行密钥交换的示例：

from cryptography.hazmat.primitives.asymmetric import x25519
from cryptography.hazmat.primitives import serialization

# 生成公钥和私钥
private_key = x25519.X25519PrivateKey.generate(default_backend())
public_key = private_key.public_key()

# 对方生成公钥和私钥
their_private_key = x25519.X25519PrivateKey.generate(default_backend())
their_public_key = their_private_key.public_key()

# 交换公钥并生成共享密钥
shared_key = private_key.exchange(their_public_key)

# 序列化公钥以便发送
serialized_public_key = public_key.public_bytes(
    encoding=serialization.Encoding.X509,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)

密钥派生

密钥派生函数（KDF）用于从密码或共享密钥派生密钥。以下是一个使用 PBKDF2 算法派生密钥的示例：

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC

# 密码和盐
password = b'your-password-here'
salt = b'your-salt-here'

# 设置 KDF 参数
kdf = PBKDF2HMAC(
    algorithm=hashes.SHA256(),
    length=32,
    salt=salt,
    iterations=100000,
    backend=default_backend()
)

# 派生密钥
derived_key = kdf.derive(password)

消息认证码（MAC）

消息认证码用于验证消息的完整性和来源。以下是一个使用 HMAC 算法生成和验证 MAC 的示例：

from cryptography.hazmat.primitives import hmac

# 密钥和数据
key = b'your-key-here'
data = b'your-data-here'

# 创建 HMAC 对象并生成 MAC
hmac_obj = hmac.HMAC(key, hashes.SHA256(), backend=default_backend())
hmac_obj.update(data)
mac = hmac_obj.finalize()

# 验证 MAC
try:
    hmac_obj = hmac.HMAC(key, hashes.SHA256(), backend=default_backend())
    hmac_obj.update(data)
    hmac_obj.verify(mac)
    print("The MAC is valid.")
except Exception as e:
    print("The MAC is invalid.")

cryptography的实际应用场景

网络通信加密

在网络通信中，确保数据安全传输至关重要。使用cryptography库可以方便地对传输的数据进行加密。

from cryptography.fernet import Fernet

# 生成密钥
key = Fernet.generate_key()
cipher_suite = Fernet(key)

# 加密数据
data = b"Hello, this is a secret message."
encrypted_data = cipher_suite.encrypt(data)

# 解密数据
decrypted_data = cipher_suite.decrypt(encrypted_data)
print(decrypted_data)

数据库加密存储

为了保护敏感数据，在数据库中存储加密数据是一种常见的做法。

from cryptography.fernet import Fernet
import sqlite3

# 生成密钥
key = Fernet.generate_key()
cipher_suite = Fernet(key)

# 连接数据库
conn = sqlite3.connect('encrypted.db')
cursor = conn.cursor()

# 创建加密表
cursor.execute('CREATE TABLE IF NOT EXISTS secrets (id INTEGER PRIMARY KEY, data BLOB)')

# 加密数据
data = b"Sensitive data"
encrypted_data = cipher_suite.encrypt(data)

# 插入加密数据
cursor.execute('INSERT INTO secrets (data) VALUES (?)', (encrypted_data,))
conn.commit()

# 查询并解密数据
cursor.execute('SELECT data FROM secrets WHERE id = 1')
encrypted_data = cursor.fetchone()[0]
decrypted_data = cipher_suite.decrypt(encrypted_data)
print(decrypted_data)

# 关闭数据库连接
conn.close()

数字签名

数字签名确保数据的完整性和验证数据的发送者。

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

# 生成密钥对
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)
public_key = private_key.public_key()

# 签名消息
message = b"Sign this message"
signature = private_key.sign(
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)

# 验证签名
try:
    public_key.verify(
        signature,
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("The signature is valid.")
except Exception as e:
    print("The signature is invalid.")

HTTPS 连接

使用cryptography库可以创建和验证 SSL/TLS 证书，确保 HTTPS 连接的安全。

from cryptography import x509
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.x509.oid import NameOID

# 生成自签名证书
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)
subject_name = x509.Name([
    x509.NameOID.COMMON_NAME, 'example.com',
    x509.NameOID.COUNTRY_NAME, 'US',
    x509.NameOID.ORGANIZATION_NAME, 'Example, Inc.',
    x509.NameOID.ORGANIZATIONAL_UNIT_NAME, 'IT',
])

builder = x509.CertificateBuilder().subject_name(
    subject_name
).issuer_name(
    subject_name
).public_key(
    private_key.public_key()
).serial_number(
    x509.random_serial_number()
).validity_period(
    x509.ValidityPeriod(
        start=x509.Date(current_time()),
        end=x509.Date(current_time() + x509 validoity_period(365 * 24 * 60 * 60)),
    )
).add_extension(
    x509.SubjectAlternativeName([
        x509.DNSName('example.com'),
    ]),
    critical=False,
)

# 签名证书
certificate = builder.sign(private_key, hashes.SHA256())

# 输出证书
with open("self_signed_cert.pem", "wb") as f:
    f.write(certificate.public_bytes(serialization.Encoding.PEM))

加密文件存储

加密文件存储可以保护敏感文件不被未经授权的人员访问。

from cryptography.fernet import Fernet

# 生成密钥
key = Fernet.generate_key()
cipher_suite = Fernet(key)

# 加密文件
with open('sensitive_file.txt', 'rb') as file:
    original_data = file.read()

encrypted_data = cipher_suite.encrypt(original_data)

with open('sensitive_file.encrypted', 'wb') as file:
    file.write(encrypted_data)

# 解密文件
with open('sensitive_file.encrypted', 'rb') as file:
    encrypted_data = file.read()

decrypted_data = cipher_suite.decrypt(encrypted_data)

with open('sensitive_file.decrypted', 'wb') as file:
    file.write(decrypted_data)

加密货币钱包

使用cryptography库可以创建加密货币钱包，生成和管理私钥和公钥。

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ed25519

# 生成 Ed25519 私钥和公钥
private_key = ed25519.generate_private_key()
public_key = private_key.public_key()

# 签名消息
message = b"Transfer 1 BTC"
signature = private_key.sign(message)

# 验证签名
try:
    public_key.verify(signature, message)
    print("The signature is valid.")
except Exception as e:
    print("The signature is invalid.")

总结

通过本文的介绍，我们深入了解了cryptography库的基本概念、特性以及如何在项目中安装和使用它。掌握了加密、解密、签名、验证等基本功能，同时也学习了更高级的对称加密、非对称加密以及混合加密技术。最后，我们探讨了cryptography在实际应用场景中的广泛应用，为今后的开发工作提供了宝贵的参考。

编程、AI、副业交流：https://t.zsxq.com/19zcqaJ2b
领【150 道精选 Java 高频面试题】请 go 公众号：码路向前 。