密码学

|
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os
 
# 使用Fernet（基于AES）进行对称加密
def encrypt_symmetric(plaintext, key):
    """使用对称加密加密数据"""
    f = Fernet(key)
    ciphertext = f.encrypt(plaintext.encode())
    return ciphertext
 
def decrypt_symmetric(ciphertext, key):
    """使用对称加密解密数据"""
    f = Fernet(key)

|
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 
def encrypt_with_gcm(plaintext, key):
    """使用AES-GCM进行加密（提供认证）"""
    aesgcm = AESGCM(key)
    # 生成随机nonce（在GCM中，nonce通常是12字节）
    nonce = os.urandom(12)
    ciphertext = aesgcm.encrypt(nonce, plaintext.encode(), None)
    return nonce + ciphertext
 
def decrypt_with_gcm(ciphertext, key):
    """使用AES-GCM进行解密"""
    aesgcm = AESGCM(key)
    nonce =

|
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend
 
def generate_rsa_keypair():
    """生成RSA密钥对"""
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048,
        backend=default_backend()
    )
    public_key = private_key.public_key()
    return

|
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization
 
def generate_ecc_keypair():
    """生成椭圆曲线密钥对"""
    private_key = ec.generate_private_key(ec.SECP256R1(), default_backend())
    public_key = private_key.public_key()
    return private_key, public_key
 
# ECC通常用于密钥交换和数字签名，而不是直接加密
# 加密通常使用ECDH（椭圆曲线Diffie-Hellman）进行密钥交换

|
def hybrid_encrypt(plaintext, public_key):
    """混合加密：使用非对称加密加密对称密钥，使用对称加密加密数据"""
    # 生成对称密钥
    symmetric_key = Fernet.generate_key()
    f = Fernet(symmetric_key)
    
    # 使用对称加密加密数据
    encrypted_data = f.encrypt(plaintext.encode())
    
    # 使用非对称加密加密对称密钥
    encrypted_key = encrypt_rsa(symmetric_key.decode(), public_key)
    
    return encrypted_key + b'|||' + encrypted_data
 
def hybrid_decrypt(ciphertext, private_key):
    """混合解密"""

|
import hashlib
 
def hash_data(data):
    """计算数据的SHA-256哈希值"""
    return hashlib.sha256(data.encode()).hexdigest()
 
# 示例
message = "这是需要哈希的数据"
hash_value = hash_data(message)
print(f"哈希值: {hash_value}")
 
# 即使数据有微小变化，哈希值也会完全不同
message2 = "这是需要哈希的数据."
hash_value2 = hash_data(message2)
print(f"修改后的哈希值: {

|
import bcrypt
 
def hash_password(password):
    """使用bcrypt哈希密码（自动生成盐）"""
    # bcrypt自动生成盐并包含在哈希值中
    hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt())
    return hashed
 
def verify_password(password, hashed):
    """验证密码"""
    return bcrypt.checkpw(password.encode(), hashed)
 
# 示例
password = "我的密码"
hashed = hash_password(password)
print(f"哈希值: {hashed}")

|
import hmac
import hashlib
 
def generate_hmac(message, key):
    """生成HMAC"""
    return hmac.new(key.encode(), message.encode(), hashlib.sha256).hexdigest()
 
def verify_hmac(message, key, received_hmac):
    """验证HMAC"""
    calculated_hmac = generate_hmac(message, key)
    return hmac.compare_digest(calculated_hmac, received_hmac)
 
# 示例
message = "这是需要认证的消息"
key = "共享密钥"
mac = generate_hmac(message, key)
print(f"MAC: 

|
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes
 
def sign_message(message, private_key):
    """使用私钥签名消息"""
    signature = private_key.sign(
        message.encode(),
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    return signature
 
def verify_signature(message, signature, public_key):

|
import secrets
 
# 使用secrets模块生成密码学安全的随机数
def generate_secure_key(length=32):
    """生成密码学安全的随机密钥"""
    return secrets.token_bytes(length)
 
# 示例
key = generate_secure_key()
print(f"密钥: {key.hex()}")