Python 开发中，使用bcrypt 或 Passlib 对系统用户密码进行哈希和验证处理

import bcrypt

password = b"supersecretpassword"
hashed = bcrypt.hashpw(password, bcrypt.gensalt())

# 验证密码
if bcrypt.checkpw(password, hashed):
    print("Password matches!")
else:
    print("Password does not match.")

from passlib.context import CryptContext

# 创建一个 CryptContext 对象
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

# 哈希密码
password = "my_secret_password"
hashed_password = pwd_context.hash(password)
print("Hashed password:", hashed_password)

# 验证密码
is_correct = pwd_context.verify(password, hashed_password)
if is_correct:
    print("密码正确")
else:
    print("密码错误")

pwd_context = CryptContext(
    schemes=["bcrypt"],
    bcrypt__rounds=12  # bcrypt 的哈希轮数，默认为 12
)

import bcrypt

# 指定的 salt（必须为 16 字节，前缀为 b"$2b$"）
salt = bcrypt.gensalt(rounds=12)  # 或者使用自定义的 16 字节 salt
print(f"Generated salt: {salt}")

# 要加密的密码
password = "my_secret_password"

# 使用指定的 salt 进行加密
hashed_password = bcrypt.hashpw(password.encode('utf-8'), salt)
print(f"Hashed password: {hashed_password}")

from passlib.context import CryptContext

# 创建一个 CryptContext 对象
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

# 自定义 salt
custom_salt = "my_custom_salt"

# 拼接 salt 和密码
password = "my_secret_password"
password_with_salt = custom_salt + password

# 对拼接后的字符串进行哈希处理
hashed_password = pwd_context.hash(password_with_salt)
print("Hashed password with custom salt:", hashed_password)

pip install cryptography

from cryptography.fernet import Fernet

# 生成密钥（注意：密钥需要安全存储）
key = Fernet.generate_key()
cipher = Fernet(key)

# 加密
message = "This is a secret message"
encrypted_message = cipher.encrypt(message.encode())
print("Encrypted:", encrypted_message)

# 解密
decrypted_message = cipher.decrypt(encrypted_message).decode()
print("Decrypted:", decrypted_message)

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

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

public_key = private_key.public_key()

# 加密
message = b"This is a secret message"
encrypted_message = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print("Encrypted:", encrypted_message)

# 解密
decrypted_message = private_key.decrypt(
    encrypted_message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print("Decrypted:", decrypted_message.decode())

private_pem = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.TraditionalOpenSSL,
    encryption_algorithm=serialization.NoEncryption()
)
with open('private_key.pem', 'wb') as f:
    f.write(private_pem)

with open('private_key.pem', 'rb') as f:
    private_key = serialization.load_pem_private_key(
        f.read(),
        password=None,
    )

public_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)
with open('public_key.pem', 'wb') as f:
    f.write(public_pem)

with open('public_key.pem', 'rb') as f:
    public_key = serialization.load_pem_public_key(f.read())