Python hashlib模块与哈希算法保护数据完整性教程

import hashlib

data = "Hello, hashlib!"
md5_hash = hashlib.md5(data.encode()).hexdigest()

print(f"MD5 Hash: {md5_hash}")

import hashlib

def calculate_file_hash(file_path, algorithm='sha256'):
    hasher = hashlib.new(algorithm)
    with open(file_path, 'rb') as file:
        while chunk := file.read(8192):
            hasher.update(chunk)
    return hasher.hexdigest()

file_path = 'example.txt'
file_hash = calculate_file_hash(file_path)

print(f"{file_path} SHA-256 Hash: {file_hash}")

import hashlib
import secrets
def hash_with_salt(data, salt_length=16, algorithm='sha256'):
    salt = secrets.token_hex(salt_length)
    data_with_salt = f"{data}{salt}".encode()
    hasher = hashlib.new(algorithm)
    hasher.update(data_with_salt)
    return {
        'hash': hasher.hexdigest(),
        'salt': salt
    }
user_password = 'secure_password'
hashed_data = hash_with_salt(user_password)
print(f"Hashed Password: {hashed_data['hash']}")
print(f"Salt: {hashed_data['salt']}")

import bcrypt

user_password = 'secure_password'
hashed_password = bcrypt.hashpw(user_password.encode(), bcrypt.gensalt())

# 在验证密码时使用 bcrypt.checkpw()
entered_password = 'secure_password'
if bcrypt.checkpw(entered_password.encode(), hashed_password):
    print("Password is correct!")
else:
    print("Incorrect password.")

import hashlib
def generate_hash(data):
    return hashlib.sha256(data.encode()).hexdigest()
# 数据传输前
original_data = "Hello, Hashing!"
original_hash = generate_hash(original_data)
# 数据传输后
received_data = "Hello, Hashing!"
received_hash = generate_hash(received_data)
if original_hash == received_hash:
    print("数据完整性验证通过")
else:
    print("数据可能被篡改")

import hashlib

def hash_password(password, salt):
    hashed_password = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 100000)
    return hashed_password

# 用户注册
user_password = "my_secure_password"
user_salt = "random_salt"
hashed_password = hash_password(user_password, user_salt)
print("哈希后的密码:", hashed_password)

# 用户登录验证
input_password = "user_input_password"
if hash_password(input_password, user_salt) == hashed_password:
    print("密码验证通过")
else:
    print("密码错误")

import hashlib

def generate_file_hash(file_path):
    hasher = hashlib.sha256()
    with open(file_path, "rb") as file:
        while chunk := file.read(8192):
            hasher.update(chunk)
    return hasher.hexdigest()

# 文件传输前
original_file_path = "example.txt"
original_file_hash = generate_file_hash(original_file_path)

# 文件传输后
received_file_path = "received_example.txt"
received_file_hash = generate_file_hash(received_file_path)

if original_file_hash == received_file_hash:
    print("文件完整性验证通过")
else:
    print("文件可能被篡改")

from Crypto.PublicKey import RSA
from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256

# 生成密钥对
key = RSA.generate(2048)
private_key = key.export_key()
public_key = key.publickey().export_key()

# 签名
message = "Hello, Digital Signature!"
hash_value = SHA256.new(message.encode())
signer = pkcs1_15.new(RSA.import_key(private_key))
signature = signer.sign(hash_value)

# 验证签名
verifier = pkcs1_15.new(RSA.import_key(public_key))
try:
    verifier.verify(hash_value, signature)
    print("数字签名验证通过")
except (ValueError, TypeError):
    print("数字签名验证失败")

import hashlib

def generate_unique_identifier(data):
    return hashlib.sha256(data.encode()).hexdigest()

# 数据标识生成
data_identifier = generate_unique_identifier("Unique Data Identifier")
print("数据唯一标识:", data_identifier)

# 创建一个散列表
hash_table = {}
# 添加元素
hash_table["key1"] = "value1"
hash_table["key2"] = "value2"
hash_table["key3"] = "value3"
# 查找元素
search_key = "key2"
if search_key in hash_table:
    print(f"{search_key} 对应的值是 {hash_table[search_key]}")
else:
    print(f"{search_key} 未找到")
# 删除元素
delete_key = "key1"
if delete_key in hash_table:
    del hash_table[delete_key]
    print(f"{delete_key} 已删除")
else:
    print(f"{delete_key} 未找到")

class HashLinkedListNode:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.next = None
class HashMap:
    def __init__(self, size):
        self.size = size
        self.table = [None] * size
    def _hash_function(self, key):
        return hash(key) % self.size
    def add_element(self, key, value):
        index = self._hash_function(key)
        if not self.table[index]:
            self.table[index] = HashLinkedListNode(key, value)
        else:
            current_node = self.table[index]
            while current_node.next:
                current_node = current_node.next
            current_node.next = HashLinkedListNode(key, value)
    def find_element(self, key):
        index = self._hash_function(key)
        current_node = self.table[index]
        while current_node:
            if current_node.key == key:
                return current_node.value
            current_node = current_node.next
        return None
# 使用哈希链表
hash_map = HashMap(size=10)
hash_map.add_element("key1", "value1")
hash_map.add_element("key2", "value2")
hash_map.add_element("key3", "value3")
search_key = "key2"
result = hash_map.find_element(search_key)
if result:
    print(f"{search_key} 对应的值是 {result}")
else:
    print(f"{search_key} 未找到")

def hash_based_sharding(data, num_shards):
    hash_value = hash(data)
    shard_index = hash_value % num_shards
    return shard_index
# 数据分片
data = "Shard me!"
num_shards = 5
shard_index = hash_based_sharding(data, num_shards)
print(f"数据 {data} 被分配到分片 {shard_index}")