Python案例如何实现SHA加密？

本文目录导读：

1. 使用hashlib模块（推荐）
2. 使用HMAC进行SHA加密
3. 密码哈希的最佳实践
4. 完整的SHA加密工具类
5. 注意事项

我来详细介绍Python中实现SHA加密的方法。

使用hashlib模块（推荐）

Python的hashlib模块提供了常见的哈希算法实现。

基础SHA加密示例

import hashlib
# 原始数据
data = "Hello, World!"
# SHA-1 加密
sha1_hash = hashlib.sha1(data.encode()).hexdigest()
print(f"SHA-1: {sha1_hash}")
# SHA-256 加密
sha256_hash = hashlib.sha256(data.encode()).hexdigest()
print(f"SHA-256: {sha256_hash}")
# SHA-512 加密
sha512_hash = hashlib.sha512(data.encode()).hexdigest()
print(f"SHA-512: {sha512_hash}")
# SHA-224 加密
sha224_hash = hashlib.sha224(data.encode()).hexdigest()
print(f"SHA-224: {sha224_hash}")
# SHA-384 加密
sha384_hash = hashlib.sha384(data.encode()).hexdigest()
print(f"SHA-384: {sha384_hash}")

对大文件进行SHA加密

import hashlib
def sha256_file(file_path):
    """计算文件的SHA-256哈希值"""
    sha256_hash = hashlib.sha256()
    with open(file_path, "rb") as f:
        # 分块读取文件，避免内存溢出
        for byte_block in iter(lambda: f.read(4096), b""):
            sha256_hash.update(byte_block)
    return sha256_hash.hexdigest()
# 使用示例
file_hash = sha256_file("example.txt")
print(f"文件SHA-256: {file_hash}")

带盐值的SHA加密

import hashlib
import os
def sha256_with_salt(password, salt=None):
    """使用盐值增强SHA加密"""
    if salt is None:
        # 生成随机盐值
        salt = os.urandom(32)
    # 组合密码和盐值
    pwd_salt = password.encode() + salt
    # 多次哈希增加安全性
    for _ in range(1000):
        pwd_salt = hashlib.sha256(pwd_salt).digest()
    return {
        'hash': pwd_salt.hex(),
        'salt': salt.hex()
    }
# 使用示例
result = sha256_with_salt("my_password")
print(f"哈希值: {result['hash']}")
print(f"盐值: {result['salt']}")

使用HMAC进行SHA加密

import hmac
import hashlib
def hmac_sha256(message, key):
    """使用HMAC进行SHA-256加密"""
    h = hmac.new(key.encode(), message.encode(), hashlib.sha256)
    return h.hexdigest()
# 使用示例
message = "重要消息"
secret_key = "密钥123"
hmac_result = hmac_sha256(message, secret_key)
print(f"HMAC-SHA256: {hmac_result}")

密码哈希的最佳实践

import hashlib
import os
import base64
def hash_password(password):
    """安全的密码哈希函数"""
    # 生成随机盐值
    salt = os.urandom(16)
    # 使用PBKDF2进行密钥派生
    password_hash = hashlib.pbkdf2_hmac(
        'sha256',           # 使用的哈希算法
        password.encode(),  # 密码字节
        salt,               # 盐值
        100000,             # 迭代次数
        dklen=32            # 派生密钥长度
    )
    # 组合盐值和哈希值
    return base64.b64encode(salt + password_hash).decode('utf-8')
def verify_password(stored_password, provided_password):
    """验证密码"""
    # 解码存储的密码
    decoded = base64.b64decode(stored_password)
    salt = decoded[:16]
    stored_hash = decoded[16:]
    # 计算提供密码的哈希
    password_hash = hashlib.pbkdf2_hmac(
        'sha256',
        provided_password.encode(),
        salt,
        100000,
        dklen=32
    )
    return stored_hash == password_hash
# 使用示例
stored_pwd = hash_password("用户密码123")
print(f"存储的密码: {stored_pwd}")
# 验证密码
is_valid = verify_password(stored_pwd, "用户密码123")
print(f"密码验证: {is_valid}")
is_invalid = verify_password(stored_pwd, "错误密码")
print(f"错误密码验证: {is_invalid}")

完整的SHA加密工具类

import hashlib
import hmac
import os
import base64
from typing import Optional, Union
class SHAEncryptor:
    """SHA加密工具类"""
    def __init__(self, algorithm: str = 'sha256'):
        """初始化加密器
        Args:
            algorithm: 支持的算法: sha1, sha224, sha256, sha384, sha512
        """
        self.algorithm = algorithm
    def encrypt_string(self, data: str) -> str:
        """加密字符串"""
        return getattr(hashlib, self.algorithm)(data.encode()).hexdigest()
    def encrypt_file(self, file_path: str, buffer_size: int = 4096) -> str:
        """加密文件"""
        hash_obj = hashlib.new(self.algorithm)
        with open(file_path, 'rb') as file:
            while True:
                data = file.read(buffer_size)
                if not data:
                    break
                hash_obj.update(data)
        return hash_obj.hexdigest()
    def encrypt_with_salt(self, data: str, salt: Optional[str] = None) -> dict:
        """带盐值加密"""
        if salt is None:
            salt = os.urandom(32).hex()
        combined = data.encode() + salt.encode()
        encrypted = getattr(hashlib, self.algorithm)(combined).hexdigest()
        return {
            'encrypted': encrypted,
            'salt': salt
        }
    def encrypt_multiple(self, *data: str) -> list:
        """批量加密多个字符串"""
        return [self.encrypt_string(item) for item in data]
# 使用示例
encryptor = SHAEncryptor('sha256')
# 基本使用
result = encryptor.encrypt_string("Hello, World!")
print(f"加密结果: {result}")
# 带盐值加密
result_with_salt = encryptor.encrypt_with_salt("密码123")
print(f"带盐值加密: {result_with_salt}")
# 批量加密
results = encryptor.encrypt_multiple("数据1", "数据2", "数据3")
print(f"批量加密: {results}")

注意事项

安全性考虑

# 不要使用简单的SHA作为密码存储
# 不安全的方式
def insecure_password_hash(password):
    return hashlib.sha256(password.encode()).hexdigest()
# 安全的方式
def secure_password_hash(password):
    """使用PBKDF2进行安全的密码哈希"""
    salt = os.urandom(16)
    key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode('utf-8'),
        salt,
        100000
    )
    return salt + key

性能对比示例

import time
def benchmark_sha():
    """测试不同SHA算法的性能"""
    data = "测试数据" * 1000
    algorithms = ['sha1', 'sha256', 'sha512']
    for algo in algorithms:
        start_time = time.time()
        for _ in range(10000):
            getattr(hashlib, algo)(data.encode()).hexdigest()
        end_time = time.time()
        print(f"{algo}: {end_time - start_time:.3f}秒")
# 运行基准测试
benchmark_sha()

• 推荐使用hashlib模块进行SHA加密
• 避免直接存储密码，使用带盐值的PBKDF2
• 根据安全需求选择合适的算法：SHA-256是目前较常用的平衡选择
• 处理大文件时使用分块读取
• 重要的加密应用场景考虑使用bcrypt、scrypt等专门的密码哈希库

这样你就可以在Python中灵活实现各种SHA加密需求了！