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

林世洪

在设计一个系统的时候，肯定都有会有用户身份认证的问题，一般对用户校验的时候，都是对用户存在数据库总的密码哈希值进行判断，从而避免密码泄露和反向解密，那么在Python 开发中，我们可以引入bcrypt 或 Passlib 对系统用户密码进行哈希和验证处理，以及介绍使用其他类库实现常规加解密处理操作。本篇随笔主要介绍bcrypt 和 Passlib 它们之间的差异，以及在实际使用中的一些代码供参考。
1、bcrypt 和 Passlib的介绍

bcrypt 和 Passlib 都是用于密码哈希和验证的 Python 库，但它们有一些显著的区别：

• bcrypt:
  
  
  
  • bcrypt 是一个专门用于实现 bcrypt 哈希算法的库。它相对简单，专注于单一功能，即对密码进行 bcrypt 哈希处理和验证。
    
  • 适合只需要 bcrypt 哈希算法的场景。
    
  • 提供的 API 简单直接，功能较少。
    
  
  
• Passlib:
  
  
  
  • Passlib 是一个更高级的密码哈希库，它支持多种哈希算法（如 bcrypt、PBKDF2、Argon2 等），并且提供了更丰富的功能。
    
  • 适合需要支持多种密码哈希算法和策略的场景。
    
  • 提供的 CryptContext 类可以方便地管理和迁移多个哈希算法。还提供了密码哈希的自动升级机制，以及对旧算法的弃用处理。
    
  
  

当你确定只需要使用 bcrypt 算法，并且不需要额外的复杂功能时，bcrypt 是一个合适的选择。它适合简单的项目，或者在需要直接控制 salt 等参数的情况下使用。
Passlib 适合复杂的项目，尤其是需要支持多个哈希算法或需要迁移哈希算法的场景。适合需要长期维护的项目，因为它提供了更多的配置和安全功能。
bcrypt: 灵活性较低，因为它只支持 bcrypt 算法。没有多种哈希算法选择或密码策略管理功能。使用简单，代码更直观。如果你只需要 bcrypt 算法，bcrypt 库可能更容易上手。
Passlib:提供了很高的灵活性和扩展性。可以根据需要切换和配置不同的哈希算法，管理复杂的密码策略。通过 CryptContext，可以轻松管理不同算法之间的过渡。功能强大但相对复杂，需要更深入的学习和理解。但它的高层 API 设计得很友好，一旦熟悉，可以简化很多常见任务。CryptContext 是其中一个用于管理多个哈希算法和密码哈希策略的类。
示例代码对比：
bcrypt 使用示例：

1. import bcrypt
3. password = b"supersecretpassword"
4. hashed = bcrypt.hashpw(password, bcrypt.gensalt())
6. # 验证密码
7. if bcrypt.checkpw(password, hashed):
8.     print("Password matches!")
9. else:
10.     print("Password does not match.")

复制代码

Passlib 使用示例：

1. from passlib.context import CryptContext
3. # 创建一个 CryptContext 对象
4. pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
6. # 哈希密码
7. password = "my_secret_password"
8. hashed_password = pwd_context.hash(password)
9. print("Hashed password:", hashed_password)
11. # 验证密码
12. is_correct = pwd_context.verify(password, hashed_password)
13. if is_correct:
14.     print("密码正确")
15. else:
16.     print("密码错误")

复制代码

定义了一个 CryptContext 对象，用于管理密码哈希算法。schemes=["bcrypt"] 表示你要使用 bcrypt 算法，而 deprecated="auto" 表示自动管理过时的哈希方案。
使用 pwd_context.hash() 方法对密码进行哈希处理。每次生成的哈希值都是唯一的，即使是相同的密码也会生成不同的哈希值。
使用 pwd_context.verify() 方法可以验证给定的密码与存储的哈希值是否匹配。
你还可以在创建 CryptContext 对象时传递更多参数来定制密码哈希行为，这种方法可以增强密码存储的安全性。例如：

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

复制代码

2、使用指定的salt进行加密

在 Passlib 中，bcrypt 算法默认会自动生成一个随机的 salt，这也是 bcrypt 的一种安全特性。如果你想使用指定的 salt 进行加密，需要注意的是，Passlib 并不直接支持通过指定 salt 来进行哈希处理，因为这可能会降低安全性。
不过，如果你确实需要使用指定的 salt 进行哈希处理，你可以使用以下的方式：

• 手动拼接 salt 和密码：可以手动拼接 salt 和密码，然后对结果进行哈希处理。但这种方法仅适用于了解风险并确保安全措施的场景。
  
• 使用 bcrypt 库：直接使用 bcrypt 库进行处理，它允许你传递一个指定的 salt。不过，注意这会有一定的安全风险。
  

1） 使用 bcrypt 库指定 salt

如果你确实需要指定 salt，可以使用 bcrypt 库。

1. import bcrypt
3. # 指定的 salt（必须为 16 字节，前缀为 b"$2b$"）
4. salt = bcrypt.gensalt(rounds=12)  # 或者使用自定义的 16 字节 salt
5. print(f"Generated salt: {salt}")
7. # 要加密的密码
8. password = "my_secret_password"
10. # 使用指定的 salt 进行加密
11. hashed_password = bcrypt.hashpw(password.encode('utf-8'), salt)
12. print(f"Hashed password: {hashed_password}")

复制代码

2） 手动拼接 salt 和密码

如果你使用 Passlib，并想使用指定的 salt，可以手动拼接 salt 和密码，然后对这个组合结果进行哈希处理。这个方式一般不建议使用，因为它破坏了 bcrypt 的安全设计原则。

1. from passlib.context import CryptContext
3. # 创建一个 CryptContext 对象
4. pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
6. # 自定义 salt
7. custom_salt = "my_custom_salt"
9. # 拼接 salt 和密码
10. password = "my_secret_password"
11. password_with_salt = custom_salt + password
13. # 对拼接后的字符串进行哈希处理
14. hashed_password = pwd_context.hash(password_with_salt)
15. print("Hashed password with custom salt:", hashed_password)

复制代码

注意事项

• 使用固定的 salt 会降低密码哈希的安全性，因为相同的 salt 和相同的密码会生成相同的哈希值。
  
• bcrypt 的设计初衷是让每次生成的 salt 都不同，以此提高安全性。
  
• 如果你需要在特定的场景下使用固定的 salt，一定要确保你的系统有足够的其他安全措施。
  

同一密码，每次获得的hash值都会不同，那么有些人会问，如果通过pwd_context.hash获得的hash值，下一次能够对比正确吗？
       回答是的，使用 pwd_context.hash() 生成的哈希值可以在后续对比中正确匹配，即使每次生成的哈希值看起来不同。Passlib 和 bcrypt 的设计确保了这一点。

• 自动生成的 salt：每次你使用 pwd_context.hash() 生成一个新的哈希值时，bcrypt 都会自动生成一个随机的 salt 并将其嵌入到生成的哈希值中。因此，即使对同一个密码进行多次哈希，每次生成的哈希值也会不同。
  
• 验证过程：在验证过程中，pwd_context.verify() 会自动从存储的哈希值中提取 salt 并重新计算哈希，然后将其与提供的哈希值进行比较。这意味着，即使哈希值不同，验证仍然能够成功匹配。
  

即使你每次运行 pwd_context.hash(password) 得到的哈希值不同（因为 salt 不同），pwd_context.verify(password, hashed_password) 仍然会返回 True，表示密码验证成功。
 
3、加密和解密处理

Passlib 主要用于密码哈希处理，并不支持加密和解密操作。如果你需要对字符串进行加密和解密，或者使用非对称加密，你需要使用其他库，例如 cryptography 或 PyCryptodome。
1）对称加密和解密

对于对称加密，你可以使用 cryptography 库中的 Fernet，它是基于 AES 算法的加密方案。
安装 cryptography 库

1. pip install cryptography

复制代码

对称加密和解密示例

1. from cryptography.fernet import Fernet
3. # 生成密钥（注意：密钥需要安全存储）
4. key = Fernet.generate_key()
5. cipher = Fernet(key)
7. # 加密
8. message = "This is a secret message"
9. encrypted_message = cipher.encrypt(message.encode())
10. print("Encrypted:", encrypted_message)
12. # 解密
13. decrypted_message = cipher.decrypt(encrypted_message).decode()
14. print("Decrypted:", decrypted_message)

复制代码

2） 非对称加密和解密

对于非对称加密，你可以使用 cryptography 库中的 RSA 算法。通常，非对称加密用于加密较短的信息或加密对称密钥。
非对称加密和解密示例

1. from cryptography.hazmat.primitives.asymmetric import rsa, padding
2. from cryptography.hazmat.primitives import serialization, hashes
4. # 生成私钥和公钥
5. private_key = rsa.generate_private_key(
6.     public_exponent=65537,
7.     key_size=2048,
8. )
10. public_key = private_key.public_key()
12. # 加密
13. message = b"This is a secret message"
14. encrypted_message = public_key.encrypt(
15.     message,
16.     padding.OAEP(
17.         mgf=padding.MGF1(algorithm=hashes.SHA256()),
18.         algorithm=hashes.SHA256(),
19.         label=None
20.     )
21. )
22. print("Encrypted:", encrypted_message)
24. # 解密
25. decrypted_message = private_key.decrypt(
26.     encrypted_message,
27.     padding.OAEP(
28.         mgf=padding.MGF1(algorithm=hashes.SHA256()),
29.         algorithm=hashes.SHA256(),
30.         label=None
31.     )
32. )
33. print("Decrypted:", decrypted_message.decode())

复制代码

3）保存和加载密钥

保存私钥:

1. private_pem = private_key.private_bytes(
2.     encoding=serialization.Encoding.PEM,
3.     format=serialization.PrivateFormat.TraditionalOpenSSL,
4.     encryption_algorithm=serialization.NoEncryption()
5. )
6. with open('private_key.pem', 'wb') as f:
7.     f.write(private_pem)

复制代码

加载私钥:

1. with open('private_key.pem', 'rb') as f:
2.     private_key = serialization.load_pem_private_key(
3.         f.read(),
4.         password=None,
5.     )

复制代码

保存公钥:

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

复制代码

加载公钥:

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

复制代码

 
我们在开发过程总，可以根据需求选择合适的加密方式和库，并妥善管理密钥。
 

来源:https://www.cnblogs.com/wuhuacong/p/18371249
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！