python中pycryptodome模块实现加密算法库

目录

• 一、简介
• 二、安装
• 三、pycryptodome之Crypto.Cipher
• 四、pycryptodome之Crypto.Hash
• 五、pycryptodome之Crypto.IO
• 六、pycryptodome之Crypto.Signature
• 七、pycryptodome之Crypto.PublicKey
• 八、pycryptodome之Crypto.Random
• 九、pycryptodome之Crypto.Util
• 十、pycryptodome之Crypto.Protocol
• 十一、pycryptodome之Crypto.Math

一、简介

PyCryptodome是PyCrypto库的一个分支，它是python中最受欢迎的密码学库之一。PyCryptodome提供了许多密码学算法和协议的实现，包括对称加密、非对称加密、消息摘要、密码哈希、数字签名等。它还提供了一些其他功能，如密码学安全随机数生成、密码学文件格式的支持等。PyCryptodome的设计目标是提供高性能和可移植性。

如果你需要更高的性能和可移植性，那么PyCryptodome可能更适合你。如果你注重安全性和易用性，并且希望遵循最佳实践，那么Cryptography可能是一个不错的选择。

二、安装

pip install pycryptodome

三、pycryptodome之Crypto.Cipher

提供了对称加密算法的实现。可以使用其中的类来创建加密器和解密器，支持常见的对称加密算法，如AES、DES、Triple DES等。

• Crypto.Cipher.AES：对称加密算法，支持不同的密钥长度（128位、192位和256位）。它是目前广泛使用的加密算法之一。

• AES.new(key, mode, use_aesni)：创建一个AES加密器/解密器对象

'''
key：表示用于加密和解密的密钥。它应该是一个字节串（bytes）类型，长度可以是16、24或32字节，对应于AES-128、AES-192和AES-256的密钥长度。
mode：表示加密模式。它应该是AES.MODE_XXX常量之一，如AES.MODE_ECB、AES.MODE_CBC等。
use_aesni：一个布尔值，表示是否使用AES-NI硬件指令集加速加密和解密操作。默认值为True。
'''
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad


key = get_random_bytes(16)# 生成随机的16字节密钥

plaintext = b'Hello, world!' #加密数据

cipher = AES.new(key, AES.MODE_ECB) # 创建 AES 加密器对象
padded_plaintext = pad(plaintext, AES.block_size)  # 填充明文数据

ciphertext = cipher.encrypt(padded_plaintext)# 加密

decrypted = cipher.decrypt(ciphertext)# 解密
decrypted_data = unpad(decrypted, AES.block_size)# 去除填充

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• AES.block_size：表示AES算法的块大小（以字节为单位），通常为16字节。
• AES.key_size：表示AES算法支持的密钥长度（以字节为单位），可以是16、24或32字节。
• AES.Buffer：表示用于加密和解密操作的缓冲区大小（以字节为单位）。
• AES.MODE_ECB：电子密码本模式，将每个明文块独立地加密成相应的密文块。ECB模式不提供加密的完全安全性，因为相同的明文块将始终加密成相同的密文块。
• AES.MODE_CBC：在CBC模式中，每个明文块会与前一个密文块进行异或操作，然后再进行加密。需要一个初始向量（IV）来开始加密过程。
• AES.MODE_CCM：CCM模式是一种组合模式，它将CTR模式和CBC-MAC（密码分组链接消息认证码）组合在一起。它提供了加密、解密和消息完整性验证的功能。
• AES.MODE_CFB：CFB模式将前一个密文块作为密钥流的一部分，然后与明文进行异或操作，产生密文。类似于CBC模式，需要一个初始向量（IV）。
• AES.MODE_CTR：CTR模式中，明文与一个计数器进行异或操作，生成密文。计数器可以是递增的，也可以是随机的，只要在加密和解密过程中保持一致即可。
• AES.MODE_EAX：EAX模式是一种组合模式，它将CTR模式和CMAC（密码分组链接消息认证码）组合在一起。它提供了加密、解密和消息完整性验证的功能。
• AES.MODE_GCM：GCM模式是一种组合模式，它将CTR模式和GMAC（Galois消息认证码）组合在一起。它提供了加密、解密和消息完整性验证的功能。
• AES.MODE_OCB：OCB模式是一种组合模式，它将CTR模式和CMAC组合在一起，并引入了一种效率更高的计算方式。它提供了加密、解密和消息完整性验证的功能。
• AES.MODE_OFB：OFB模式将前一个密文块作为密钥流的一部分，然后与明文进行异或操作，产生密文。类似于CFB模式，不需要初始向量（IV）。
• AES.MODE_OPENPGP）：OpenPGP模式是一种扩展的加密模式，用于与OpenPGP协议兼容的系统。
• AES.MODE_SIV：SIV模式是一种认证加密模式，它提供了加密、解密和消息完整性验证的功能，并允许使用相同的密钥对多个消息进行加密，而不会泄漏关于明文的信息。

• Crypto.Cipher.ARC2：对称加密算法，密钥长度可变，通常为40位。它是一种较旧的加密算法，现在很少使用。

• ARC2.new(key,mode,iv,IV,nonce,segment_size,mac_len, initial_value,counter)：创建一个ARC2加密器/解密器对象

'''
key：ARC2 加密算法使用的密钥。它应该是一个字节字符串，并且长度必须在 1 到 128 字节之间（包括边界值）。
mode：指定 ARC2 加密模式。可以使用以下常量之一：
iv或IV：初始化向量 (Initialization Vector)，用于在加密过程中引入随机性。它应该是一个字节字符串，并且长度必须与算法的块大小相同。在某些模式下，如 ECB 模式，iv 参数可以被忽略。
nonce：用于计数器模式的随机数。它应该是一个字节字符串，并且长度必须与算法的块大小相同。
segment_size：在 CFB 模式中，指定数据分段的大小（以位为单位）。默认值为 8。
mac_len：在 EAX 模式中，指定消息认证码 (MAC) 的长度（以字节为单位）。默认值为 16。
initial_value：在计数器模式中，指定初始计数器值。它应该是一个整数。默认值为 0。
counter：在计数器模式中，指定计数器对象。它应该是一个 Crypto.Util.Counter 类的实例。
'''
from Crypto.Cipher import ARC2
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad,unpad

key = get_random_bytes(16)  # 生成随机密钥
plaintext = b"Hello, world!"  # 要加密的数据

cipher = ARC2.new(key, ARC2.MODE_CBC)  # 创建 ARC2 加密器对象
padded_data = pad(plaintext, cipher.block_size)  # 对数据进行填充
ciphertext = cipher.encrypt(padded_data)  # 加密数据

decipher = ARC2.new(key, ARC2.MODE_CBC,cipher.iv)  # 创建 ARC2 加密器对象
decrypted = decipher.decrypt(ciphertext)  # 解密数据
decrypted_data = unpad(decrypted, cipher.block_size) # 去除填充

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• ARC2.block_size：ARC2 算法的块大小，以字节为单位。在 pycryptodome 中，ARC2 的块大小为 8 字节。
• ARC2.key_size：ARC2 算法支持的密钥长度，以字节为单位。在 pycryptodome 中，ARC2 的密钥长度可以在 1 到 128 字节之间。
• ARC2.Buffer：在 pycryptodome 中，ARC2 加密器对象的内部缓冲区。
• ARC2.MODE_ECB：电子密码本模式。在 ECB 模式下，每个块独立地进行加密或解密，没有引入随机性。
• ARC2.MODE_CBC：密码分组链接模式 。在 CBC 模式下，每个块的加密依赖于前一个块的密文，引入了随机性。
• ARC2.MODE_CFB：密码反馈模式 。在 CFB 模式下，每个块的加密依赖于前一个块的密文和密钥流，引入了随机性。
• ARC2.MODE_OFB：输出反馈模式。在 OFB 模式下，每个块的加密依赖于前一个块的密钥流，引入了随ChaCha20机性。
• ARC2.MODE_CTR：计数器模式。在 CTR 模式下，每个块的加密依赖于计数器值和密钥流，引入了随机性。
• ARC2.MODE_OPENPGP：OpenPGP 模式。在 OpenPGP 模式下，使用了特定的密钥派生函数和密钥流生成算法。
• ARC2.MODE_EAX：EAX 模式。EAX 是一种认证加密模式，同时提供加密和认证功能。

• Crypto.Cipher.ARC4：对称加密算法，也被称为RC4。它是一种流密码算法，密钥长度可变。它简单高效，但由于一些安全性问题，现在不推荐使用。

• ARC4.new(key,drop)：创建一个ARC4加密器/解密器对象

'''
key：表示要使用的密钥。密钥是一个字节串（bytes），长度可以根据需要进行调整。通常情况下，密钥的长度应该与算法要求的密钥长度相匹配。
drop：表示在生成初始密钥流之前要丢弃的初始字节数。这个参数是可选的，默认值为 0。在某些应用中，可以选择在开始加密之前丢弃一些初始字节，以增加密钥流的随机性。
'''
from Crypto.Cipher import ARC4
from Crypto.Random import get_random_bytes

key = get_random_bytes(16)  # 生成随机密钥
plaintext = b"Hello, world!"  # 要加密的数据

cipher = ARC4.new(key)  # 创建 ARC4 加密器对象
ciphertext = cipher.encrypt(plaintext)  # 加密数据

decipher = ARC4.new(key)  # 创建 ARC4 解密器对象
decrypted_data = decipher.decrypt(ciphertext)  # 解密数据

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• ARC4.block_size：加密算法的块大小。对于 RC4 算法而言，它是一个流密码算法，没有固定的块大小，因此 block_size 的值为 1。
• ARC4.key_size：加密算法支持的密钥长度。对于 RC4 算法而言，密钥可以是任意长度的字节串，因此 key_size 的值为可变的，没有固定的长度限制。
• ARC4.Buffer：RC4 算法内部使用的缓冲区大小。在 pycryptodome 中，这个值默认为 4096。当加密器对象的缓冲区中的数据被消耗完之后，会自动重新生成新的密钥流并填充缓冲区。

• Crypto.Cipher.Blowfish：对称加密算法，密钥长度可变。它是一种快速且安全的加密算法，适用于各种应用场景。

• Blowfish.new(key,mode,iv,IV,nonce,segment_size,mac_len ,initial_value,counter) ：创建一个Blowfish加密器/解密器对象

'''
key：表示要使用的密钥。密钥是一个字节串（bytes），长度可以根据需要进行调整。Blowfish 算法支持的密钥长度可以是 8 到 448 位之间的任意长度。
mode：表示加密模式。这个参数是可选的，默认值为 MODE_ECB，表示使用电子密码本模式。其他可选的模式包括 MODE_CBC（密码分组链接模式）和 MODE_CFB（密码反馈模式）等。
iv 或 IV：表示初始化向量。这个参数是可选的，用于在加密过程中增加随机性。对于 ECB 模式，不需要提供初始化向量；对于其他模式，通常需要提供一个与块大小相匹配的初始化向量。
nonce：表示使用的随机数。这个参数是可选的，用于在加密过程中增加随机性。通常与 CTR 模式一起使用。
segment_size：表示 CFB 模式中的分段大小。这个参数是可选的，默认值为 8。在 CFB 模式中，明文被分成固定大小的分段进行加密。
mac_len：表示消息认证码的长度。这个参数是可选的，默认值为 None，表示不使用消息认证码。
initial_value：表示初始值。这个参数是可选的，用于在某些模式下设置初始值。
counter：表示计数器的初始值。这个参数是可选的，用于在 CTR 模式下设置计数器的初始值。
'''
from Crypto.Cipher import Blowfish
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad

key = get_random_bytes(16)  # 生成随机密钥
plaintext = b"Hello, World!"  # 要加密的明文

# 创建 Blowfish 加密器对象，使用 CBC 模式和随机的初始化向量
cipher = Blowfish.new(key, mode=Blowfish.MODE_CBC, iv=get_random_bytes(8))
padded_plaintext = pad(plaintext, cipher.block_size)  # 填充明文数据
ciphertext = cipher.encrypt(padded_plaintext)  # 加密明文

decipher = Blowfish.new(key, mode=Blowfish.MODE_CBC, iv=cipher.iv)  # 创建 Blowfish 加密器对象
decrypted = decipher.decrypt(ciphertext)  # 解密数据
decrypted_data = unpad(decrypted, cipher.block_size)  # 去除填充

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• Blowfish.block_size：Blowfish 算法的分组大小（以字节为单位）。对于 Blowfish 算法，分组大小固定为 8 字节。
• Blowfish.Buffer：Blowfish 加密器对象的内部缓冲区的大小（以字节为单位）。在 pycryptodome 中，默认的缓冲区大小为 4096 字节。
• Blowfish.key_size：Blowfish 算法支持的密钥长度（以位为单位）。对于 Blowfish 算法，密钥长度可以是 32 到 448 位之间的任意长度。
• Blowfish.MODE_CBC：Blowfish 加密算法的密码分组链接模式。在该模式下，每个明文分组在加密之前会与前一个密文分组进行异或运算。
• Blowfish.MODE_CFB：Blowfish 加密算法的密码反馈模式。在该模式下，明文分组的一部分会被加密，然后与明文分组的下一部分进行异或运算。
• Blowfish.MODE_CTR：Blowfish 加密算法的计数器模式。在该模式下，明文分组会与计数器进行加密，计数器的值会根据分组的索引逐渐递增。
• Blowfish.MODE_EAX：Blowfish 加密算法的 EAX 模式。在该模式下，可以同时进行加密和消息认证，并提供附加数据的完整性验证。
• Blowfish.MODE_OFB：Blowfish 加密算法的输出反馈模式。在该模式下，密钥流会被生成并与明文分组进行异或运算，然后输出密文。
• Blowfish.MODE_OPENPGP：Blowfish 加密算法的 OpenPGP 模式。该模式与 CFB 模式类似，但使用了不同的填充和反馈函数。
• Blowfish.MODE_ECB：Blowfish 加密算法的电子密码本模式。在该模式下，每个明文分组都会独立地进行加密。

• Crypto.Cipher.CAST：对称加密算法，密钥长度可变。它是一种安全性较高的加密算法，适用于各种应用场景。

• CAST.new(key,mode,iv,IV,nonce,segment_size,mac_len ,initial_value,counter)：创建一个CAST加密器/解密器对象

'''
key：要使用的密钥。密钥是一个字节串（bytes），长度可以是 5 到 16 字节之间的任意长度。
mode：加密模式。可以使用以下常量来指定加密模式：
iv 或 IV：初始化向量（Initialization Vector）。初始化向量是一个字节串（bytes），长度固定为 8 字节。在某些加密模式下，如 CBC、CFB 和 OFB，需要提供一个初始化向量。
nonce：使用的随机数。这个参数是一个字节串（bytes），长度通常为 8 字节。在 CTR 模式下，需要提供一个随机的 nonce。
segment_size：分段大小（以字节为单位）。在 CFB 模式下，可以指定分段大小，取值范围为 1 到 8 之间的整数。
mac_len：消息认证码的长度（以字节为单位）。在 CCM 和 EAX 模式下，可以指定消息认证码的长度。
initial_value：初始值。在 CTR 模式下，可以指定初始值。
counter：计数器的初始值。在 CTR 模式下，可以指定计数器的初始值。
'''
from Crypto.Cipher import CAST
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad

key = get_random_bytes(16)  # 生成随机密钥
plaintext = b"Hello, World!"  # 要加密的明文

# 创建 CAST 加密器对象，使用 CBC 模式和随机的初始化向量
cipher = CAST.new(key, mode=CAST.MODE_CBC, iv=get_random_bytes(8))
padded_plaintext = pad(plaintext, cipher.block_size)  # 填充明文数据
ciphertext = cipher.encrypt(padded_plaintext)  # 加密明文

decipher = CAST.new(key, mode=CAST.MODE_CBC, iv=cipher.iv)  # 创建 CAST 加密器对象
decrypted = decipher.decrypt(ciphertext)  # 解密数据
decrypted_data = unpad(decrypted, cipher.block_size)  # 去除填充

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• CAST.block_size：CAST 算法的分组大小（以字节为单位）。对于 CAST 算法，分组大小固定为 8 字节。
• CAST.key_size：CAST 算法支持的密钥长度（以位为单位）。对于 CAST 算法，密钥长度可以是 40 位到 128 位之间的任意长度。
• CAST.Buffer：CAST 加密器对象的内部缓冲区的大小（以字节为单位）。在 pycryptodome 中，默认的缓冲区大小为 4096 字节。
• CAST.MODE_CBC：CAST 加密算法的密码分组链接模式。在该模式下，每个明文分组在加密之前会与前一个密文分组进行异或运算。
• CAST.MODE_ECB：CAST 加密算法的电子密码本模式。在该模式下，每个明文分组都会独立地进行加密。
• CAST.MODE_OPENPGP：CAST 加密算法的 OpenPGP 模式。该模式与 CFB 模式类似，但使用了不同的填充和反馈函数。
• CAST.MODE_OFB：CAST 加密算法的输出反馈模式。在该模式下，密钥流会被生成并与明文分组进行异或运算，然后输出密文。
• CAST.MODE_EAX：CAST 加密算法的 EAX 模式。在该模式下，可以同时进行加密和消息认证，并提供附加数据的完整性验证。
• CAST.MODE_CTR：CAST 加密算法的计数器模式。在该模式下，明文分组会与计数器进行加密，计数器的值会根据分组的索引逐渐递增。
• CAST.MODE_CFB：CAST 加密算法的密码反馈模式。在该模式下，明文分组的一部分会被加密，然后与明文分组的下一部分进行异或运算。

• Crypto.Cipher.ChaCha20：对称加密算法，密钥长度为256位。它是一种高速的加密算法，适用于资源受限的环境。

• ChaCha20.new(key,nonce)：创建一个ChaCha20加密器/解密器对象

'''
key：要使用的密钥。密钥是一个字节串（bytes），长度固定为 32 字节。
nonce：使用的随机数。这个参数是一个字节串（bytes），长度可以是 8 字节或 12 字节。
'''
from Crypto.Cipher import ChaCha20
from Crypto.Random import get_random_bytes

# 生成随机密钥和随机 nonce
key = get_random_bytes(32)
nonce = get_random_bytes(12)

cipher = ChaCha20.new(key=key, nonce=nonce)# 创建 ChaCha20 加密器对象
plaintext = b"Hello, World!"# 要加密的明文
ciphertext = cipher.encrypt(plaintext) # 加密明文

decrypt_cipher = ChaCha20.new(key=key, nonce=nonce) # 创建新的 ChaCha20 加密器对象，使用相同的密钥和 nonce
decrypted_data = decrypt_cipher.decrypt(ciphertext) # 解密密文

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• ChaCha20.block_size：ChaCha20 算法的分组大小（以字节为单位）。对于 ChaCha20 算法，分组大小固定为 64 字节。
• ChaCha20.key_size：ChaCha20 算法支持的密钥长度（以位为单位）。对于 ChaCha20 算法，密钥长度固定为 256 位。
• ChaCha20.Buffer：ChaCha20 加密器对象的内部缓冲区的大小（以字节为单位）。在 pycryptodome 中，默认的缓冲区大小为 4096 字节

  7.Crypto.Cipher.ChaCha20_Poly1305：对称加密算法，结合了ChaCha20和Poly1305消息认证码。它提供了高速的加密和完整性保护。

• ChaCha20_Poly1305.new(key,nonce)：创建一个ChaCha20_Poly1305加密器/解密器对象

'''
key：要使用的密钥。密钥是一个字节串（bytes），长度固定为 32 字节。
nonce：使用的随机数。这个参数是一个字节串（bytes），长度可以是 8 字节或 12 字节。
'''
from Crypto.Cipher import ChaCha20_Poly1305
from Crypto.Random import get_random_bytes

# 生成随机密钥和随机 nonce
key = get_random_bytes(32)
nonce = get_random_bytes(12)

cipher = ChaCha20_Poly1305.new(key=key, nonce=nonce)# 创建 ChaCha20 加密器对象
plaintext = b"Hello, World!"# 要加密的明文
ciphertext = cipher.encrypt(plaintext) # 加密明文

decrypt_cipher = ChaCha20_Poly1305.new(key=key, nonce=nonce) # 创建新的 ChaCha20 加密器对象，使用相同的密钥和 nonce
decrypted_data = decrypt_cipher.decrypt(ciphertext) # 解密密文

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• ChaCha20_Poly1305.block_size：ChaCha20_Poly1305 算法的分组大小（以字节为单位）。对于 ChaCha20_Poly1305 算法，分组大小固定为 64 字节。
• ChaCha20_Poly1305.key_size：ChaCha20_Poly1305 算法支持的密钥长度（以位为单位）。对于 ChaCha20_Poly1305 算法，密钥长度固定为 256 位。
• ChaCha20_Poly1305.Buffer：ChaCha20_Poly1305 加密器对象的内部缓冲区的大小（以字节为单位）。在 pycryptodome 中，默认的缓冲区大小为 4096 字节。

• Crypto.Cipher.DES：对称加密算法，密钥长度为56位。它是一种较旧的加密算法，现在不推荐使用。

• DES.new(key,mode,iv,IV,nonce,segment_size,mac_len ,initial_value,counter)：创建一个DES加密器/解密器对象

'''
key：要使用的密钥。密钥是一个字节串（bytes），长度固定为 8 字节。
mode：加密模式。可以使用以下常量来指定加密模式：
iv 或 IV：初始化向量（Initialization Vector）。初始化向量是一个字节串（bytes），长度固定为 8 字节。在某些加密模式下，如 CBC、CFB 和 OFB，需要提供一个初始化向量。
nonce：使用的随机数。这个参数是一个字节串（bytes），长度通常为 8 字节。在 CTR 模式下，需要提供一个随机的 nonce。
segment_size：分段大小（以字节为单位）。在 CFB 模式下，可以指定分段大小，取值范围为 1 到 8 之间的整数。
mac_len：消息认证码的长度（以字节为单位）。在 CCM 和 EAX 模式下，可以指定消息认证码的长度。
initial_value：初始值。在 CTR 模式下，可以指定初始值。
counter：计数器的初始值。在 CTR 模式下，可以指定计数器的初始值
'''
from Crypto.Cipher import DES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad

key = get_random_bytes(8)  # 生成随机的8字节密钥

plaintext = b'Hello, world!'  # 加密数据

cipher = DES.new(key, DES.MODE_ECB)  # 创建 DES 加密器对象
padded_plaintext = pad(plaintext, DES.block_size)  # 填充明文数据

ciphertext = cipher.encrypt(padded_pla编程客栈intext)  # 加密

decrypted = cipher.decrypt(ciphertext)  # 解密
decrypted_data = unpad(decrypted, DES.block_size)  # 去除填充

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• DES.key_size：DES 加密算法支持的密钥大小（以位为单位）。在 DES 中，密钥大小固定为 56 位。
• DES.block_size：DES 加密算法的分组大小（以字节为单位）。在 DES 中，分组大小固定为 8 字节。
• DES.MODE_ECB：DES 加密算法的电子密码本模式（Electronic Codebook）。在 ECB 模式下，每个分组都独立地进行加密，相同的明文分组将得到相同的密文分组。
• DES.MODE_CFB：DES 加密算法的密码反馈模式（Cipher Feedback）。在 CFB 模式下，前一个密文分组被反馈给加密器，用于生成下一个密文分组。
• DES.MODE_CTR：DES 加密算法的计数器模式（Counter）。在 CTR 模式下，每个分组都使用一个唯一的计数器值进行加密，计数器值通过加密器生成。
• DES.MODE_EAX：DES 加密算法的 EAX 模式。EAX 模式提供了加密、认证和扩展性。
• DES.MODE_OFB：DES 加密算法的输出反馈模式（Output Feedback）。在 OFB 模式下，前一个密文分组被反馈给加密器，用于生成密钥流，然后与明文进行异或运算得到密文。
• DES.MODE_OPENPGP：DES 加密算法的 OpenPGP 模式。
• DES.MODE_CBC：DES 加密算法的密码分组链接模式（Cipher Block Chaining）。在 CBC 模式下，每个明文分组先与前一个密文分组进行异或运算，然后再进行加密。

• Crypto.Cipher.DES3：对称加密算法，也被称为Triple DES。密钥长度为168位，由3个56位的子密钥组成。它提供了较高的安全性，但速度较慢。

• DES3.new(key,mode,iv,IV,nonce,segment_size,mac_len ,initial_value,counter)：创建一个DES3加密器/解密器对象

'''
key：表示要使用的密钥。密钥是一个字节串（bytes），长度必须为 16 或 24 字节。
mode：表示加密模式。可以使用以下常量进行指定：
iv 或 IV：表示初始化向量。这个参数是一个字节串（bytes），长度必须为 8 字节。
nonce：表示使用的随机数。这个参数是一个字节串（bytes），长度必须为 8 字节。
segment_size：表示用于 CFB 模式的分段大小（以位为单位）。默认值为 8。
mac_len：表示 EAX 模式中认证标签的长度（以字节为单位）。默认值为 8。
initial_value：表示 CTR 模式中初始计数器值。这个参数是一个整数，默认值为 0。
'''
from Crypto.Cipher import DES3
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad

key = get_random_bytes(24)  # 生成随机的8字节密钥

plaintext = b'Hello, world!'  # 加密数据

cipher = DES3.new(key, DES3.MODE_ECB)  # 创建 DES3 加密器对象
padded_plaintext = pad(plaintext, cipher.block_size)  # 填充明文数据

ciphertext = cipher.encrypt(padded_plaintext)  # 加密

decrypt_cipher = DES3.new(key, DES3.MODE_ECB)  # 创建新的 DES3 加密器对象
decrypted = decrypt_cipher.decrypt(ciphertext)  # 解密
decrypted_data = unpad(decrypted, cipher.block_size)  # 去除填充

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• DES3.block_size：DES3 加密算法的分组大小（以字节为单位）。在 DES3 中，分组大小固定为 8 字节。
• DES3.key_size：DES3 加密算法支持的密钥大小（以位为单位）。在 DES3 中，密钥大小可以是 128 位（16 字节）或 192 位（24 字节）。
• DES3.Buffer：DES3 加密算法的缓冲区大小（以字节为单位）。
• DES3.MODE_CBC：DES3 加密算法的密码分组链接模式（Cipher Block Chaining）。在 CBC 模式下，每个明文分组先与前一个密文分组进行异或运算，然后再进行加密。
• DES3.MODE_ECB：DES3 加密算法的电子密码本模式（Electronic Codebook）。在 ECB 模式下，每个分组都独立地进行加密，相同的明文分组将得到相同的密文分组。
• DES3.MODE_OPENPGP：DES3 加密算法的 OpenPGP 模式。
• DES3.MODE_OFB：DES3 加密算法的输出反馈模式（Output Feedback）。在 OFB 模式下，前一个密文分组被反馈给加密器，用于生成密钥流，然后与明文进行异或运算得到密文。
• DES3.MODE_EAX：DES3 加密算法的 EAX 模式。EAX 模式提供了加密、认证和扩展性。
• DES3.MODE_CTR：DES3 加密算法的计数器模式（Counter）。在 CTR 模式下，每个分组都使用一个唯一的计数器值进行加密，计数器值通过加密器生成。
• DES3.MODE_CFB：DES3 加密算法的密码反馈模式（Cipher Feedback）。在 CFB 模式下，前一个密文分组被反馈给加密器，用于生成下一个密文分组。
• DES3.adjust_key_parity(key_in)：用于调整密钥的奇偶校验位，确保密钥的正确性。

• Crypto.Cipher.PKCS1_OAEP：非对称加密算法，使用OAEP（Optimal Asymmetric Encryption Padding）填充方案。它用于加密和解密数据，通常与RSA密钥一起使用。

• PKCS1_OAEP.new(key,hashAlgo,mgfunc,label,randfunc)：创建一个PKCS1_OAEP加密器/解密器对象

'''
key：RSA 密钥对象（公钥或私钥）。
hashAlgo：哈希算法，用于计算散列值。可以使用 Crypto.Hash 模块中的哈希算法，例如 Crypto.Hash.SHA256。
mgfunc：掩码生成函数（Mask Generation Function），用于生成掩码以进行填充。默认为 None，表示使用标准的 MGF1。
label：可选参数，用于标识消息的标签。默认为 b''。
randfunc：可选参数，用于生成随机数。默认为 None，表示使用 Crypto.Random 模块中的默认随机数生成器。
'''
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Hash import SHA256

key = RSA.generate(2048)  # 生成 RSA 密钥对
plaintext = b'Hello, world!'  # 加密数据

cipher = PKCS1_OAEP.new(key, hashAlgo=SHA256)  # 创建 PKCS1_OAEP 加密器对象
ciphertext = cipher.encrypt(plaintext)  # 加密

decrypt_cipher = PKCS1_OAEP.new(key, hashAlgo=SHA256)  # 创建 PKCS1_OAEP 加密器对象
decrypted = decrypt_cipher.decrypt(ciphertext)  # 解密

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted)

• PKCS1_OAEP.Buffer 一个字节串（bytes）类型的缓冲区。在使用 PKCS1_OAEP 加密器和解密器对象时，可以将其用作密钥、明文和密文的参数类型。
• PKCS1_OAEP.HashLike 一个类似于哈希对象的类型。在使用 PKCS1_OAEP 加密器和解密器对象时，可以将其用作哈希算法的参数类型。

• Crypto.Cipher.PKCS1_v1_5：非对称加密算法，使用PKCS#1 v1.5填充方案。它用于加密和解密数据，通常与RSA密钥一起使用。

• PKCS1_v1_5.new(key,randfunc)：创建一个PKCS1_v1_5加密器/解密器对象

'''
key：RSA 密钥对象，可以是公钥或私钥。这个密钥对象用于进行加密或解密操作。
randfunc：一个可调用对象，用于生成随机数。如果提供了 randfunc，它将被用于生成加密过程中需要的随机字节。如果未提供 randfunc，则会使用默认的随机数生成器
'''
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5

key = RSA.generate(2048)  # 生成 RSA 密钥对
plaintext = b'Hello, world!'  # 加密数据

cipher = PKCS1_v1_5.new(key)  # 创建 PKCS1_v1_5 加密器对象
ciphertext = cipher.encrypt(plaintext)  # 加密

decrypt_cipher = PKCS1_v1_5.new(key)  # 创建 PKCS1_v1_5 加密器对象
decrypted = decrypt_cipher.decrypt(ciphertext, None)  # 解密

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted)

• PKCS1_v1_5.Buffer 一个字节串（bytes）类型的缓冲区。在使用 PKCS1_v1_5 加密器和解密器对象时，可以将其用作明文和密文的参数类型。

• Crypto.Cipher.Salsa20：对称加密算法，密钥长度为256位。它是一种高速的加密算法，适用于资源受限的环境。

• Salsa20.new(key,nonce)：创建一个Salsa20加密器/解密器对象

'''
key：Salsa20 密钥，一个字节串（bytes）类型的密钥。密钥长度可以是 16 字节（128 位）或 32 字节（256 位）。
nonce：Salsa20 随机数，一个字节串（bytes）类型的随机数。它用于与密钥一起生成加密流。
'''

from Crypto.Cipher import Salsa20

key = b'0123456789abcdef'  # 16 字节密钥
nonce = b'87654321'  # 8 字节随机数

plaintext = b'Hello, world!'# 明文数据

cipher = Salsa20.new(key,nonce)  # 创建 Salsa20 加密器对象
ciphertext = cipher.encrypt(plaintext)  # 加密

decrypt_cipher = Salsa20.new(key,nonce)  # 创建 Salsa20 加密器对象
decrypted = decrypt_cipher.decrypt(ciphertext)  # 解密

print('原始数据:', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted)

• Salsa20.Buffer：一个字节串（bytes）类型的缓冲区。它用于描述 Salsa20 加密器和解密器对象的参数类型。
• Salsa20.key_size：Salsa20 密钥的长度，单位为字节。在 pycryptodome 中，Salsa20 密钥长度可以是 16 字节（128 位）或 32 字节（256 位）。
• Salsa20.block_size：Salsa20 加密算法的块大小，单位为字节。在 pycryptodome 中，Salsa20 的块大小固定为 64 字节。

四、pycryptodome之Crypto.Hash

提供了哈希函数的实现。可以使用其中的类来计算消息的哈希值，支持常见的哈希算法，如MD5、SHA-1、SHA-256等。

1.Crypto.Hash.MD2：MD2哈希算法

• MD2.Buffer：表示 MD2 哈希函数的缓冲区大小。
• MD2.block_size：表示 MD2 哈希函数的输入块大小，即每次处理的数据块大小。
• MD2.digest_size：表示 MD2 哈希函数的输出摘要的字节大小。
• MD2.new(data=None)：用于创建一个新的 MD2 哈希对象

from Crypto.Hash import MD2

data = 'hello word'.encode('utf-8')

md2 = MD2.new(data)

print('十六进制哈希值：',md2.hexdigest())
print('十六字节哈希值：',md2.digest())
print('哈希算法的分块大小：',md2.block_size)
print('哈希算法的哈希值大小：',md2.digest_size)
print('拷贝当前哈希对象：',md2.copy())

md2.update('hello'.encode('utf-8'))

print('十六进制哈希值：',md2.hexdigest())

• Crypto.Hash.MD4：MD4哈希算法

• MD4.Buffer：表示 MD4 哈希函数的缓冲区大小。
• MD4.block_size：表示 MD4 哈希函数的输入块大小，即每次处理的数据块大小。
• MD4.digest_size：表示 MD4 哈希函数的输出摘要的字节大小。
• MD4.new(data=None)：用于创建一个新的 MD4 哈希对象

from Crypto.Hash import MD4

data = 'hello word'.encode('utf-8')

md4 = MD4.new(data)

print('十六进制哈希值：',md4.hexdigest())
print('十六字节哈希值：',md4.digest())
print('哈希算法的分块大小：',md4.block_size)
print('哈希算法的哈希值大小：',md4.digest_size)
print('拷贝当前哈希对象：',md4.copy())

md4.update('hello'.encode('utf-8'))

print('十六进制哈希值：',md4.hexdigest())

• Crypto.Hash.MD5：MD5哈希算法

• MD5.Buffer：表示 MD5 哈希函数的缓冲区大小。
• MD5.block_size：表示 MD5 哈希函数的输入块大小，即每次处理的数据块大小。
• MD5.digest_size：表示 MD5 哈希函数的输出摘要的字节大小。
• MD5.new(data=None)：用于创建一个新的 MD5 哈希对象

from Crypto.Hash import MD5

data = 'hello word'.encode('utf-8')

md5 = MD5.new(data)

print('十六进制哈希值：',md5.hexdigest())
print('十六字节哈希值：',md5.digest())
print('哈希算法的分块大小：',md5.block_size)
print('哈希算法的哈希值大小：',md5.digest_size)
print('拷贝当前哈希对象：',md5.copy())

md5.update('hello'.encode('utf-8'))

print('十六进制哈希值：',md5.hexdigest())

• Crypto.Hash.SHA256：SHA256哈希算法

• SHA256.Buffer：表示 SHA256 哈希函数的缓冲区大小。
• SHA256.block_size：表示 SHA256 哈希函数的输入块大小，即每次处理的数据块大小。
• SHA256.digest_size：表示 SHA256 哈希函数的输出摘要的字节大小。
• SHA256.new(data=None)：用于创建一个新的 SHA256 哈希对象

from Crypto.Hash import SHA256

data = 'hello word'.encode('utf-8')

sha256 = SHA256.new(data)

print('十六进制哈希值：',sha256.hexdigest())
print('十六字节哈希值：',sha256.digest())
print('哈希算法的分块大小：',sha256.block_size)
print('哈希算法的哈希值大小：',sha256.digest_size)
print('拷贝当前哈希对象：',sha256.copy())

sha256.update('hello'.encode('utf-8'))

print('十六进制哈希值：',sha256.hexdigest())

• Crypto.Hash.SHA1：SHA1哈希算法

• SHA1.Buffer：表示 SHA1 哈希函数的缓冲区大小。
• SHA1.block_size：表示 SHA1 哈希函数的输入块大小，即每次处理的数据块大小。
• SHA1.digest_size：表示 SHA1 哈希函数的输出摘要的字节大小。
• SHA1.new(data=None)：用于创建一个新的 SHA1 哈希对象

from Crypto.Hash import SHA1

data = 'hello word'.encode('utf-8')

sha1 = SHA1.new(data)

print('十六进制哈希值：',sha1.hexdigest())
print('十六字节哈希值：',sha1.digest())
print('哈希算法的分块大小：',sha1.block_size)
print('哈希算法的哈希值大小：',sha1.digest_size)
print('拷贝当前哈希对象：',sha1.copy())

sha1.update('hello'.encode('utf-8'))

print('十六进制哈希值：',sha1.hexdigest())

• Crypto.Hash.SHA224：SHA224哈希算法

• SHA224.Buffer：表示 SHA224 哈希函数的缓冲区大小。
• SHA224.block_size：表示 SHA224 哈希函数的输入块大小，即每次处理的数据块大小。
• SHA224.digest_size：表示 SHA224 哈希函数的输出摘要的字节大小。
• SHA224.new(data=None)：用于创建一个新的 SHA224 哈希对象

from Crypto.Hash import SHA224

data = 'hello word'.encode('utf-8')

sha224 = SHA224.new(data)

print('十六进制哈希值：',sha224.hexdigest())
print('十六字节哈希值：',sha224.digest())
print('哈希算法的分块大小：',sha224.block_size)
print('哈希算法的哈希值大小：',sha224.digest_size)
print('拷贝当前哈希对象：',sha224.copy())

sha224.update('hello'.encode('utf-8'))

print('十六进制哈希值：',sha224.hexdigest())

• Crypto.Hash.SHA384：SHA384哈希算法

• SHA384.Buffer：表示 SHA384 哈希函数的缓冲区大小。
• SHA384.block_size：表示 SHA384 哈希函数的输入块大小，即每次处理的数据块大小。
• SHA384.digest_size：表示 SHA384 哈希函数的输出摘要的字节大小。
• SHA384.new(data=None)：用于创建一个新的 SHA384 哈希对象

from Crypto.Hash import SHA384

data = 'hello word'.encode('utf-8')

sha384 = SHA384.new(data)

print('十六进制哈希值：',sha384.hexdigest())
print('十六字节哈希值：',sha384.digest())
print('哈希算法的分块大小：',sha384.block_size)
print('哈希算法的哈希值大小：',sha384.digest_size)
print('拷贝当前哈希对象：',sha384.copy())

sha384.update('hello'.encode('utf-8'))

print('十六进制哈希值：',sha384.hexdigest())

• Crypto.Hash.SHA512：SHA512哈希算法

• SHA512.Buffer：表示 SHA512 哈希函数的缓冲区大小。
• SHA512.block_size：表示 SHA512 哈希函数的输入块大小，即每次处理的数据块大小。
• SHA512.digest_size：表示 SHA512 哈希函数的输出摘要的字节大小。
• SHA512.new(data=None)：用于创建一个新的 SHA512 哈希对象

from Crypto.Hash import SHA512

data = 'hello word'.encode('utf-8')

sha512 = SHA512.new(data)

print('十六进制哈希值：',sha512.hexdigest())
print('十六字节哈希值：',sha512.digest())
print('哈希算法的分块大小：',sha512.block_size)
print('哈希算法的哈希值大小：',sha512.digest_size)
print('拷贝当前哈希对象：',sha512.copy())

sha512.update('hello'.encode('utf-8'))

print('十六进制哈希值：',sha512.hexdigest())

• Crypto.Hash.SHA3_224：SHA3_224哈希算法

• SHA3_224.Buffer：表示 SHA3_224 哈希函数的缓冲区大小。
• SHA3_224.block_size：表示 SHA3_224 哈希函数的输入块大小，即每次处理的数据块大小。
• SHA3_224.digest_size：表示 SHA3_224 哈希函数的输出摘要的字节大小。
• SHA3_224.new(data=None,update_after_digest)：用于创建一个新的 SHA3_224 哈希对象

from Crypto.Hash import SHA3_224

data = 'hello word'.encode('utf-8')

sha3_224 = SHA3_224.new(data,update_after_digest=True)

print('十六进制哈希值：',sha3_224.hexdigest())
print('十六字节哈希值：',sha3_224.digest())
print('哈希算法的分块大小：',sha3_224.block_size)
print('哈希算法的哈希值大小：',sha3_224.digest_size)
print('拷贝当前哈希对象：',sha3_224.copy())

sha3_224.update('hello'.encode('utf-8'))

print('十六进制哈希值：',sha3_224.hexdigest())

• Crypto.Hash.SHA3_256：SHA3_256哈希算法

• SHA3_256.Buffer：表示 SHA3_256 哈希函数的缓冲区大小。
• SHA3_256.block_size：表示 SHA3_256 哈希函数的输入块大小，即每次处理的数据块大小。
• SHA3_256.digest_size：表示 SHA3_256 哈希函数的输出摘要的字节大小。
• SHA3_256.new(data=None,update_after_digest)：用于创建一个新的 SHA3_256 哈希对象

from Crypto.Hash import SHA3_256

data = 'hello word'.encode('utf-8')

sha3_256 = SHA3_256.new(data,update_after_digest=True)

print('十六进制哈希值：',sha3_256.hexdigest())
print('十六字节哈希值：',sha3_256.digest())
print('哈希算法的分块大小：',sha3_256.block_size)
print('哈希算法的哈希值大小：',sha3_256.digest_size)
print('拷贝当前哈希对象：',sha3_256.copy())

sha3_256.update('hello'.encode('utf-8'))

print('十六进制哈希值：',sha3_256.hexdigest())

• Crypto.Hash.SHA3_384：SHA3_384哈希算法

• SHA3_384.Buffer：表示 SHA3_384 哈希函数的缓冲区大小。
• SHA3_384.block_size：表示 SHA3_384 哈希函数的输入块大小，即每次处理的数据块大小。
• SHA3_384.digest_size：表示 SHA3_384 哈希函数的输出摘要的字节大小。
• SHA3_384.new(data=None,update_after_digest)：用于创建一个新的 SHA3_384 哈希对象

from Crypto.Hash import SHA3_384

data = 'hello word'.encode('utf-8')

sha3_384 = SHA3_384.new(data,update_after_digest=True)

print('十六进制哈希值：',sha3_384.hexdigest())
print('十六字节哈希值：',sha3_384.digest())
print('哈希算法的分块大小：',sha3_384.block_size)
print('哈希算法的哈希值大小：',sha3_384.digest_size)
print('拷贝当前哈希对象：',sha3_384.copy())

sha3_384.update('hello'.encode('utf-8'))

print('十六进制哈希值：',sha3_384.hexdigest())

• Crypto.Hash.SHA3_512：SHA3_512哈希算法

• SHA3_512.Buffer：表示 SHA3_512 哈希函数的缓冲区大小。
• SHA3_512.block_size：表示 SHA3_512 哈希函数的输入块大小，即每次处理的数据块大小。
• SHA3_512.digest_size：表示 SHA3_512 哈希函数的输出摘要的字节大小。
• SHA3_512.new(data=None,update_after_digest)：用于创建一个新的 SHA3_512 哈希对象

from Crypto.Hwww.devze.comash import SHA3_512

data = 'hello word'.encode('utf-8')

sha3_512 = SHA3_512.new(data,update_after_digest=True)

print('十六进制哈希值：',sha3_512.hexdigest())
print('十六字节哈希值：',sha3_512.digest())
print('哈希算法的分块大小：',sha3_512.block_size)
print('哈希算法的哈希值大小：',sha3_512.digest_size)
print('拷贝当前哈希对象：',sha3_512.copy())

sha3_512.update('hello'.encode('utf-8'))

print('十六进制哈希值：',sha3_512.hexdigest())

• Crypto.Hash.SHAKE128：SHAKE128哈希算法，SHA-3 衍生的可变长度哈希函数，可以生成不同长度的哈希值

• SHAKE128.Buffer：SHAKE128 哈希函数的缓冲区大小。
• SHAKE128.new(data)：创建一个新的 SHAKE128 哈希对象。

from Crypto.Hash import SHAKE128

data = b'hello word'

shake128 = SHAKE128.new(data)

shake128.update(b'hello')

print('字节哈希值：', shake128.read(10))

• Crypto.Hash.SHAKE256：SHAKE256哈希算法，SHA-3 衍生的可变长度哈希函数，可以生成不同长度的哈希值

• SHAKE256.Buffer：SHAKE256 哈希函数的缓冲区大小。
• SHAKE256.new(data)：创建一个新的 SHAKE256 哈希对象。

from Crypto.Hash import SHAKE256

data = b'hello word'

shake256 = SHAKE256.new(data)

shake256.update(b'hello')

print('字节哈希值：', shake256.read(10))

• Crypto.Hash.HMAC：这是基于哈希函数的密钥相关的消息认证码算法。它可以使用不同的哈希算法（如 SHA256、SHA512 等）来计算消息认证码。

• HMAC.Buffer：表示 HMAC 哈希函数的缓冲区大小。
• HMAC.digest_size：表示 HMAC 哈希函数输出的摘要（哈希值）的大小，以字节为单位。
• HMAC.new(key, msg, digestmod)：创建一个新的 HMAC 哈希对象

'''
key：密钥
msg：消息
digestmod：哈希算法，常见的哈希算法包括 SHA1、SHA256、SHA512 等。
'''
from Crypto.Hash import HMAC,MD5

key = b'my_secret_key'
message = b'Hello, world!'

hmac = HMAC.new(key,message,MD5)

print('十六进制哈希值：',hmac.hexdigest())
print('十六字节哈希值：',hmac.digest())
print('哈希算法的哈希值大小：',hmac.digest_size)
print('拷贝当前哈希对象：',hmac.copy())
print('验证十六字节哈希值：',hmac.verify(hmac.digest()))
print('验证十六进制哈希值：',hmac.hexverify(hmac.hexdigest()))

• Crypto.Hash.CMAC：这是一种基于对称加密算法的消息认证码算法。它使用一个密钥和一个块加密算法（如 AES）来计算消息认证码。

• CMAC.Buffer：是一个常量，表示 CMAC 算法的缓冲区大小。
• CMAC.digest_size：表示 CMAC 算法输出的摘要（MAC 值）的大小，以字节为单位。
• CMAC.new(key, msg, ciphermod, cipher_params, mac_len, update_after_digest)：用于创建一个新的 CMAC 算法对象

'''
key：表示用于计算 CMAC 的密钥，是一个字节串。
msg：表示要计算 CMAC 的消息，也是一个字节串。
ciphermod：表示底层使用的对称加密算法模块，例如 Crypto.Cipher.AES、Crypto.Cipher.DES 等。
cipher_params：表示底层对称加密算法的参数，例如 AES 加密算法的参数可以是一个字节串表示的密钥。
mac_len：表示期望的 MAC 长度，以字节为单位。如果不指定，默认为底层对称加密算法的块大小。
update_after_digest：布尔值，表示在计算完摘要后是否允许继续更新 CMAC 对象。如果为 True，可以继续调用 update() 方法更新 CMAC 对象；如果为 False，在计算完摘要后调用 update() 方法将引发异常。默认为 False。
'''
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Hash import CMAC

key = get_random_bytes(16)  # 生成随机密钥
plaintext = b"Hello, world!"  # 要加密的数据


cmac = CMAC.new(key, plaintext, ciphermod=AES, mac_len=8,update_after_digest=True)

print('十六进制哈希值：', cmac.hexdigest())
print('十六字节哈希值：', cmac.digest())
print('哈希算法的哈希值大小：', cmac.digest_size)
print('拷贝当前哈希对象：', cmac.copy())
print('验证十六字节哈希值：', cmac.verify(cmac.digest()))
print('验证十六进制哈希值：', cmac.hexverify(cmac.hexdigest()))

cmac.update(b'hello')
print('十六进制哈希值：', cmac.hexdigest())

• Crypto.Hash.RIPEMD160：RIPEMD160哈希算法

• RIPEMD160.digest_size：RIPEMD-160 哈希值的字节大小。
• RIPEMD160.block_size：RIPEMD-160 算法的分块大小。
• RIPEMD160.Buffer：RIPEMD-160 哈希值的缓冲区。
• RIPEMD160.new(data=None)：创建一个新的 RIPEMD160 哈希对象

from Crypto.Hash import RIPEMD160

data = 'hello word'.encode('utf-8')

ripemd160 = RIPEMD160.new(data)

print('十六进制哈希值：', ripemd160.hexdigest())
print('十六字节哈希值：', ripemd160.digest())
print('哈希算法的分块大小：', ripemd160.block_size)
print('哈希算法的哈希值大小：', ripemd160.digest_size)
print('拷贝当前哈希对象：', ripemd160.copy())

ripemd160.update('hello'.encode('utf-8'))

print('十六进制哈希值：', ripemd160.hexdigest())

• Crypto.Hash.KMAC128：KMAC128哈希算法

• KMAC128.Buffer： KMAC128 哈希值的缓冲区。
• KMAC128.new(key, data=None, mac_len=None, custom=None)：创建一个新的 KMAC128 哈希对象

'''
key：密钥。它是一个字节串（bytes），用于计算哈希值和认证标签。
data：要计算哈希值的数据。它是一个字节串（bytes）。
mac_len：期望的哈希值的长度（以比特为单位）。如果未指定，将使用默认的哈希值长度。
custom：自定义字符串，用于与密钥一起计算哈希值和认证标签。它是一个字节串（bytes）
'''
from Crypto.Hash import KMAC128
from Crypto.Random import get_random_bytes

key = get_random_bytes(16)  # 密钥
data = b"Hello, world!"  # 要计算哈希值的数据
mac_len = 16  # MAC 长度
custom = b"custom_string"  # 自定义字符串

kmac128 = KMAC128.new(key=key, data=data, mac_len=mac_len, custom=custom)

# kmac128.update(b"hello")

print('十六进制哈希值：', kmac128.hexdigest())
print('十六字节哈希值：', kmac128.digest())
print('验证十六字节哈希值：', kmac128.verify(kmac128.digest()))
print('验证十六进制哈希值：', kmac128.hexverify(kmac128.hexdigest()))

• Crypto.Hash.KMAC256：这些是基于 Keccak 算法的可变长度哈希函数，可以生成不同长度的哈希值。

• KMAC256.Buffer：KMAC128 哈希值的缓冲区。
• KMAC256.new(key, data=None, mac_len=None, custom=None)：创建一个新的 KMAC256 哈希对象

'''
key：密钥。它是一个字节串（bytes），用于计算哈希值和认证标签。
data：要计算哈希值的数据。它是一个字节串（bytes）。
mac_len：期望的哈希值的长度（以比特为单位）。如果未指定，将使用默认的哈希值长度。
custom：自定义字符串，用于与密钥一起计算哈希值和认证标签。它是一个字节串（bytes）
'''
from Crypto.Hash import KMAC256
from Crypto.Random import get_random_bytes

key = get_random_bytes(32)  # 密钥
data = b"Hello, world!"  # 要计算哈希值的数据
mac_len = 32  # MAC 长度
custom = b"custom_string"  # 自定义字符串

kmac256 = KMAC256.new(key=key, data=data, mac_len=mac_len, custom=custom)

# kmac256.update(b"hello")

print('十六进制哈希值：', kmac256.hexdigest())
print('十六字节哈希值：', kmac256.digest())
print('验证十六字节哈希值：', kmac256.verify(kmac256.digest()))
print('验证十六进制哈希值：', kmac256.hexverify(kmac256.hexdigest()))

• Crypto.Hash.TupleHash128：基于 Keccak 算法的元组哈希函数，用于将多个输入值组合成单个哈希值

• TupleHash128.Buffer：TupleHash128 哈希值的缓冲区。
• TupleHash128.new(digest_bytes,digest_bits,custom)：创建一个新的 TupleHash128 哈希对象

'''
digest_bytes：必要计算哈希值的数据。它是一个字节串（bytes）。
digest_bits：期望的哈希值的长度（以比特为单位）。
custom：自定义字符串，用于计算哈希值。它是一个字节串（bytes）
'''
from Crypto.Hash import TupleHash128


custom = b"Hello, world!"  # 消息数据


tulphash128 = TupleHash128.new(digest_bytes=32,custom=custom)

tulphash128.update(b'hello')

print('十六进制哈希值：', tulphash128.hexdigest())
print('十六字节哈希值：', tulphash128.digest())

• Crypto.Hash.TupleHash256：这些是基于 Keccak 算法的元组哈希函数，用于将多个输入值组合成单个哈希值。

• TupleHash256.Buffer：TupleHash256 哈希值的缓冲区。
• TupleHash256.new(digest_bytes,digest_bits,custom)：创建一个新的 TupleHash256 哈希对象

'''
digest_bytes：必要计算哈希值的数据。它是一个字节串（bytes）。
digest_bits：期望的哈希值的长度（以比特为单位）。
custom：自定义字符串，用于计算哈希值。它是一个字节串（bytes）
'''
from Crypto.Hash import TupleHash256


custom = b"Hello, world!"  # 消息数据


tulphash256 = TupleHash256.new(digest_bytes=32,custom=custom)

tulphash256.update(b'hello')

print('十六进制哈希值：', tulphash256.hexdigest())
print('十六字节哈希值：', tulphash256.digest())

• Crypto.Hash.BLAKE2s：BLAKE2 系列的哈希函数，提供高速和安全的哈希计算

• BLAKE2s.Buffer：BLAKE2s 哈希值的缓冲区。
• BLAKE2s.new(data,digest_bytesdigest_bitskey,update_after_digest)：创建一个新的 BLAKE2s 哈希对象

'''
data：要计算哈希值的数据。它是一个字节串（bytes）。
digest_bytes：期望的哈希值的长度（以字节为单位），默认的哈希值长度（32 字节），与digest_bits参数冲突
digest_bits：期望的哈希值的长度（以比特为单位），默认的哈希值长度（256 比特），与digest_bytes参数冲突
key：用于计算哈希值的密钥。它是一个字节串（bytes）。如果未提供该参数，则不使用密钥进行计算。
update_after_digest：在计算哈希值后是否允许继续更新数据。如果设置为 True，则可以在计算哈希值后继续使用 update() 方法添加更多数据
'''
from Crypto.Hash import BLAKE2s
from Crypto.Random import get_random_bytes


key = get_random_bytes(32)  # 密钥
data = b"Hello, world!"  # 要计算哈希值的数据
digest_bits = 32  # MAC 长度
custom = b"custom_string"  # 自定义字符串

blake2s = BLAKE2s.new(data=data,digest_bytes=32,key=key,update_after_digest=True)

print('十六进制哈希值：', blake2s.hexdigest())
print('十六字节哈希值：', blake2s.digest())
print('验证十六字节哈希值：', blake2s.verify(blake2s.digest()))
print('验证十六进制哈希值：', blake2s.hexverify(blake2s.hexdigest()))

blake2s.update(b"hello")
print('十六进制哈希值：', blake2s.hexdigest())

• Crypto.Hash.BLAKE2b：BLAKE2 系列的哈希函数，提供高速和安全的哈希计算

• BLAKE2b.Buffer：BLAKE2b 哈希值的缓冲区。
• BLAKE2b.new(data,digest_bytesdigest_bitskey,update_after_digest)：创建一个新的BLAKE2b 哈希对象php

'''
data：要计算哈希值的数据。它是一个字节串（bytes）。
digest_bytes：期望的哈希值的长度（以字节为单位），默认的哈希值长度（32 字节），与digest_bits参数冲突
digest_bits：期望的哈希值的长度（以比特为单位），默认的哈希值长度（256 比特），与digest_bytes参数冲突
key：用于计算哈希值的密钥。它是一个字节串（bytes）。如果未提供该参数，则不使用密钥进行计算。
update_after_digest：在计算哈希值后是否允许继续更新数据。如果设置为 True，则可以在计算哈希值后继续使用 update() 方法添加更多数据
'''
from Crypto.Hash import BLAKE2b
from Crypto.Random import get_random_bytes


key = get_random_bytes(32)  # 密钥
data = b"Hello, world!"  # 要计算哈希值的数据
digest_bits = 32  # MAC 长度
custom = b"custom_string"  # 自定义字符串

blake2b = BLAKE2b.new(data=data,digest_bytes=32,key=key,update_after_digest=True)

print('十六进制哈希值：', blake2b.hexdigest())
print('十六字节哈希值：', blake2b.digest())
print('验证十六字节哈希值：', blake2b.verify(blake2b.digest()))
print('验证十六进制哈希值：', blake2b.hexverify(blake2b.hexdigest()))

blake2b.update(b"hello")
print('十六进制哈希值：', blake2b.hexdigest())

• Crypto.Hash.KangarooTwelve：这是一种快速的哈希函数，适用于各种应用场景。

• KangarooTwelve.Buffer：KangarooTwelve 哈希值的缓冲区。

'''
data：要计算哈希值的数据。它可以是字节串（bytes）、字节数组（bytearray）或可迭代对象，例如字符串。如果是可迭代对象，它将在计算哈希值之前被转换为字节串。
custom：可选的自定义字符串。它是一个字节串（bytes），用于在计算哈希值时添加自定义的上下文信息。如果不提供 custom 参数，则默认为 None
'''
from Crypto.Hash import KangarooTwelve


data = b"Hello, world!"  # 消息数据
custom = b"Hello, world!"  # 消息数据


kangarootwelve = KangarooTwelve.new(data,custom)

# kangarootwelve.update(b"hello")

print('十六进制哈希值：', kangarootwelve.read(36))

• Crypto.Hash.Poly1305：这是一种消息认证码算法，用于计算消息的认证标签。

• Poly1305.Buffer：Poly1305 哈希值的缓冲区。
• Poly1305.new(key, cipher, nonce, data)：创建一个新的Poly1305 哈希对象

'''
key：用于计算认证标签的密钥。它是一个字节串（bytes），长度为 32 字节。Poly1305 算法要求密钥长度为 256 比特。
cipher：用于加密消息的加密算法。它是一个可调用的加密函数，接受两个参数：密钥和 nonce。该函数将返回一个加密器对象，用于加密数据。
nonce：用于加密消息的一次性值。它是一个字节串（bytes），长度为 16 字节。每个消息都应该使用不同的 nonce 值，以确保安全性。
data：要计算认证标签的消息数据。它是一个字节串（bytes）
'''
from Crypto.Cipher import ChaCha20
from Crypto.Hash import Poly1305
from Crypto.Random import get_random_bytes

key = get_random_bytes(32)  # 密钥
nonce = get_random_bytes(12)  # 一次性值
data = b"Hello, world!"  # 消息数据

cipher = ChaCha20.new(key=key, nonce=nonce)  # 创建 ChaCha20 加密器
encrypted_data = cipher.encrypt(data)  # 加密消息数据

POLY1305 = Poly1305.new(key=key, cipher=ChaCha20, nonce=nonce, data=encrypted_data)

# POLY1305.update(b"hello")

print('十六进制哈希值：', POLY1305.hexdigest())
print('十六字节哈希值：', POLY1305.digest())
print('验证十六字节哈希值：', POLY1305.verify(POLY1305.digest()))
print('验证十六进制哈希值：', POLY1305.hexverify(POLY1305.hexdigest()))

五、pycryptodome之Crypto.IO

提供了一些输入输出相关www.devze.com的功能。例如，可以使用其中的类来进行文件的加密和解密操作。

• Crypto.IO.PEM：处理 PEM（Privacy-Enhanced Mail）格式的数据。PEM 是一种常见的用于存储和传输加密数据的格式，如证书、私钥等。PEM 模块可以用于读取、写入和解析 PEM 格式的数据

• PEM.encode(data,marke,passphrase,randfunc)：编码为 PEM 数据

data：要编码为 PEM 格式的二进制数据。可以是字节串或可迭代对象，如字符串或字节数组。

marker：可选参数，表示 PEM 数据块的标记（marker）。默认值为 None，表示没有标记。如果提供了标记，将在 PEM 数据块的起始行和结束行之间添加标记。

passphrase：可选参数，用于加密 PEM 数据块的密码短语（passphrase）。默认值为 None，表示不加密。如果提供了密码短语，将使用它对 PEM 数据块进行加密。

randfunc：可选参数，用于生成随机数据的随机数生成器函数。默认值为 None，表示使用默认的随机数生成器。如果需要加密 PEM 数据块，则需要提供一个随机数生成器函数。 

• PEM.decode(pem_data, passphrase)：解码 PEM 数据

'''
pem_data：要解码的 PEM 格式数据，可以是字节串或字符串。它应该包含完整的 PEM 数据块，包括起始行（如 "-----BEGIN XYZ-----"）和结束行（如 "-----END XYZ-----"）。
passphrase：可选参数，用于解密加密的 PEM 数据块的密码短语（passphrase）。如果 PEM 数据块未加密，则可以将此参数设置为 None 或省略。
'''
from Crypto.IO import PEM

data = b'Hello, world!'  # 待编码的数据

pem_data = PEM.encode(data, 'DATA')  # 编码为 PEM 格式

decoded_data = PEM.decode(pem_data)  # 解码EM 格式

print('原数据：', data)
print('编码后的数据：', pem_data)
print('解码后的数据：', decoded_data)

• Crypto.IO.PKCS8：处理 PKCS8格式的数据。PKCS8是一种标准的格式，用于存储和传输公钥和私钥。PKCS8 模块可以用于读取、写入和解析 PKCS8格式的数据。

• PKCS8.wrap(private_key,key_oid,passphrase,protection,prot_params,key_params,randfunc)：将私钥包装为 PKCS8 格式的加密私钥信息

private_key: 要包装的私钥对象。可以是 Crypto.PublicKey.RSA、Crypto.PublicKey.DSA 或 Crypto.PublicKey.ECC 等类型的私钥对象。

key_oid: 表示私钥算法的对象标识符（OID）。默认值为 None，表示使用默认的 OID。

passphrase: 用于加密私钥的密码短语（passphrase）。可以是字符串或字节串。

protection: 加密算法的标识符，用于保护私钥数据。可以是字符串或字节串。常见的值包括 "PBKDF2WithHMAC-SHA256AndAES256-CBC" 和 "PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC"。

prot_params: 保护参数，用于指定加密算法的参数。可以是字典或 None。

key_params: 私钥参数，用于指定私钥的格式和编码方式。可以是字典或 None。

randfunc: 用于生成随机数据的随机数生成器函数。默认值为 None，表示使用默认的随机数生成器。 

• PKCS8.unwrap(p8_private_key, passphrase)：解密包含有加密私钥信息的 PKCS8 格式数据

'''
p8_private_key: 包含加密私钥信息的 PKCS#8 格式数据。可以是字节串或字符串。
passphrase: 解密私钥的密码短语（passphrase）。可以是字符串或字节串。
'''

六、pycryptodome之Crypto.Signature

提供了数字签名算法的实现。可以使用其中的类来进行数字签名和验证，支持常见的数字签名算法

• Crypto.Signature.PKCS1_v1_5：PKCS1_v1_5 是一种经典的 RSA 签名方案，使用 RSA 密钥对进行签名和验证。该方案在许多应用中广泛使用。

'''
rsa_key：RSA 密钥对象。它可以是一个 Crypto.PublicKey.RSA 对象，表示一个 RSA 密钥对。可以使用 RSA.generate() 方法来生成密钥对，或者使用 Crypto.PublicKey.RSA.import_key() 方法从已有的密钥数据中导入密钥对
'''
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import MD5

key = RSA.generate(2048)  # 生成 RSA 密钥对plaintext = b'Hello, world!'  # 加密数据signer = PKCS1_v1_5.new(key) # 创建 PKCS1_v1_5 验证对象# 数据data = b"Hello, world!"# 使用私钥进行签名hash_value = MD5.new(data)
signature = signer.sign(hash_value)

verifier = PKCS1_v1_5.new(key) # 创建 PKCS1_v1_5 验证对象print("验证密钥RSA密钥是否适用PKCS1_v1_5签名:", verifier.can_sign())
print("签名验证结果:", verifier.verify(hash_value, signature))

• Crypto.Signature.PKCS1_PSS：使用 RSA 密钥对进行签名和验证，PKCS1_PSS 是一种更现代的 RSA 签名方案，提供更好的安全性和抗攻击性能。

'''
rsa_key：RSA 密钥对象。它可以是一个 Crypto.PublicKey.RSA 对象，表示一个 RSA 密钥对。可以使用 RSA.generate() 方法来生成密钥对，或者使用 Crypto.PublicKey.RSA.import_key() 方法从已有的密钥数据中导入密钥对。
mgfunc：消息生成函数。它是一个可选参数，用于指定一个哈希算法，用于生成消息的掩码。默认值为 Crypto.Hash.MGF1。
saltLen：盐的长度。它是一个可选参数，用于指定盐的长度（以字节为单位）。默认值为 Crypto.Signature.PKCS1_PSS.MAX_LENGTH，表示使用与密钥长度相同的盐长度。
randfunc：随机数生成函数。它是一个可选参数，用于生成随机数。默认值为 Crypto.Random.get_random_bytes。
'''
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_PSS
from Crypto.Hash import MD5

key = RSA.generate(2048)  # 生成 RSA 密钥对
plaintext = b'Hello, world!'  # 加密数据

signer = PKCS1_PSS.new(key) # 创建PKCS1_PSS验证对象

# 数据
data = b"Hello, world!"

# 使用私钥进行签名
hash_value = MD5.new(data)
signature = signer.sign(hash_value)

verifier = PKCS1_PSS.new(key) # 创建PKCS1_PSS验证对象

print("验证密钥RSA密钥是否适用PKCS1_PSS签名:", verifier.can_sign())
print("签名验证结果:", verifier.verify(hash_value, signature))

• Crypto.Signature.DSS：使用 DSA 密钥对进行签名和验证，适用于需要较短签名长度和高性能的场景，DSA 是一种非对称加密算法，用于数字签名

'''
key：DSA 密钥对象，可以使用 Crypto.PublicKey.DSA 类生成密钥对，并将私钥或公钥对象传递给构造函数。
mode：字符串，指定 DSS 签名模式。可以使用 'fips-186-3' 或 'deterministic-rfc6979'。
encoding：字符串，指定消息的编码方式。可以使用 'raw' 或 'der'。
randfunc：可选参数，用于生成随机数的函数。如果不提供此参数，则使用默认的随机数生成函数。
'''
from Crypto.PublicKey import DSA
from Crypto.Signature import DSS
from Crypto.Hash import SHA256

key = DSA.generate(2048)  # 生成 DSA 密钥对
plaintext = b'Hello, world!'  # 加密数据
mode = 'fips-186-3'

signer = DSS.new(key, mode)  # 创建 DSS 签名对象

hash_value = SHA256.new(plaintext)
signature = signer.sign(hash_value)

verifier = DSS.new(key, mode)  # 创建 DSS 验证对象

print("验证密钥 DSA 密钥是否适用 DSS 签名:", verifier.can_sign())
print("签名验证结果:", verifier.verify(hash_value, signature))

七、pycryptodome之Crypto.PublicKey

提供了非对称加密算法（公钥加密算法）的实现。可以使用其中的类来生成密钥对、进行加密和解密操作，支持常见的非对称加密算法，如RSA、DSA等。

• Crypto.PublicKey.RSA：RSA 提供了 RSA 密钥对的生成、加密和解密功能。

• RSA.RsaKey：RsaKey 是一个类，表示 RSA 密钥对。它是 RSA 密钥对的基类，包括公钥和私钥。

RSA.RsaKey.e：公钥指数。在 RSA 密钥对中，公钥由指数 e 和模数 n 组成。

RSA.RsaKey.n：模数。在 RSA 密钥对中，模数 n 是一个大整数，用于加密和解密操作。

RSA.RsaKey.d：私钥指数。在 RSA 密钥对中，私钥由指数 d 和模数 n 组成。

RSA.RsaKey.invp：p 的模反元素。在 RSA 密钥对中，p 是模数 n 的一个素因子。

RSA.RsaKey.invq：q 的模反元素。在 RSA 密钥对中，q 是模数 n 的另一个素因子。

RSA.RsaKey.q：n 的另一个素因子。

RSA.RsaKey.p：n 的一个素因子。

RSA.RsaKey.u：p 的模反元素。

RSA.RsaKey.export_key(format, passphrase, pkcs, protection, randfunc)：将密钥导出为字符串。该方法与 exportKey 方法相同，只是方法名不同。

RSA.RsaKey.public_key()：返回公钥对象。该方法与 publickey 方法相同，只是方法名不同。

RSA.RsaKey.can_encrypt()：检查密钥是否可用于加密操作。

RSA.RsaKey.can_sign()：检查密钥是否可用于签名操作。

RSA.RsaKey.has_private()：检查密钥是否包含私钥。

RSA.RsaKey.size_in_bits()：返回密钥的位数。

RSA.RsaKey.size_in_bytes()：返回密钥的字节数。 

• RSA.construct(rsa_components)：用于根据给定的 RSA 组件构造 RSA 密钥对，返回RsaKey对象

rsa_components 是一个字典，包含了 RSA 密钥的组件，如 n（模数）、e（公钥指数）、d（私钥指数）等。 

• RSA.generate(bits, randfunc, e=65537)：用于生成指定位数的 RSA 密钥对，返回RsaKey对象

bits 是密钥的位数

randfunc 是一个随机数生成函数

e 是公钥指数，默认为 65537。 

• RSA.import_key(extern_key, passphrase)：用于从外部密钥（如 PEM 格式的密钥文件）中导入 RSA 密钥，返回RsaKey对象

extern_key 是一个表示外部密钥的字符串或文件对象

passphrase 是密钥的密码（如果有的话）。 

• Crypto.PublicKey.DSA：提供了 DSA 密钥对的生成、签名和验证功能。

• DSA.DsaKey：表示 DSA 密钥对，包括公钥和私钥。

DSA.DsaKey.public_key()：返回公钥对象。该方法返回一个新的 DSA.DsaKey 对象，表示 DSA 密钥对的公钥部分。

DSA.DsaKey.export_key(format, pkcs8, passphrase, protection, randfunc)：将密钥导出为字符串。该方法可以接受多个参数，包括 format（导出格式，默认为 PEM）、pkcs8（是否使用 PKCS#8 格式，默认为 False）、passphrase（密钥的密码，可选）、protection（密钥的保护级别，默认为 None）和 randfunc（随机数生成函数，可选）。

DSA.DsaKey.has_private()：检查密钥是否包含私钥。

DSA.DsaKey.can_sign()：检查密钥是否可用于签名操作。

DSA.DsaKey.can_encrypt()：检查密钥是否可用于加密操作。

DSA.DsaKey.domain()：返回 DSA 密钥对的域参数。该方法返回一个字典，包含了 DSA 密钥对的参数，如 p（素数）、q（素数）、g（生成元）等。 

• DSA.generate(bits, randfunc, domain)：用于生成指定位数的 DSA 密钥对，返回DsaKey对象

bits 是密钥的位数

randfunc 是一个随机数生成函数

domain 是一个字典，包含了 DSA 密钥对的域参数，如 p（素数）、q（素数）、g（生成元）等。 

• DSA.import_key(extern_key, passphrase)：用于从外部密钥（如 PEM 格式的密钥文件）中导入 DSA 密钥，返回DsaKey对象

extern_key 是一个表示外部密钥的字符串或文件对象

passphrase 是密钥的密码（如果有的话）。 

• DSA.construct(tup, consistency_check)：construct 是一个函数，用于根据给定的元组构造 DSA 密钥对，返回DsaKey对象

tup 是一个元组，包含了 DSA 密钥的组件，如 y（公钥）、x（私钥）、p（素数）、q（素数）、g（生成元）等

consistency_check 是一个布尔值，表示是否进行一致性检查。 

• Crypto.PublicKey.ElGamal：提供了 ElGamal 密钥对的生成、加密和解密功能。

• ElGamal.ElGamalKey：表示 ElGamal密钥对

ElGamal.ElGamalKey.can_sign()：用于检查密钥对是否可以用于签名操作。如果密钥对包含私钥，则可以进行签名操作，该方法将返回 True；否则，返回 False。

ElGamal.ElGamalKey.can_encrypt()：用于检查密钥对是否可以用于加密操作。如果密钥对包含公钥，则可以进行加密操作，该方法将返回 True；否则，返回 False。

ElGamal.ElGamalKey.has_private()：用于检查密钥对是否包含私钥。如果密钥对包含私钥，则返回 True；否则，返回 False。

ElGamal.ElGamalKey.publickey()：用于获取密钥对的公钥部分。它返回一个新的 ElGamal.ElGamalPublicKey 对象，其中只包含公钥信息，不包含私钥信息。 

• ElGamal.generate(bits, randfunc)：用于生成指定位数的 ElGamal 密钥对

bits 是密钥的位数

randfunc 是一个随机数生成函数。 

• ElGamal.construct(tup)：用于根据给定的元组构造 ElGamal 密钥对

tup 是一个元组，包含了 ElGamal 密钥的组件，如 p（素数）、g（生成元）、y（公钥）、x（私钥）等。 

• Crypto.PublicKey.ECC：提供了 ECC 密钥对的生成、加密和解密功能。

• ECC.EccKey：表示 ECC密钥对

ECC.EccKey.d：表示 ECC 密钥对的私钥。

ECC.EccKey.curve：c表示 ECC 密钥对所使用的椭圆曲线。

ECC.EccKey.pointQ：表示 ECC 密钥对的公钥点。

ECC.EccKey.export_key(format='PEM')：用于导出 ECC 密钥对的数据。format 参数指定导出的格式，默认为 'PEM' 格式。

ECC.EccKey.public_key()：用于获取 ECC 密钥对的公钥部分。它返回一个新的 ECC.EccKey 对象，其中只包含公钥信息，不包含私钥信息。

ECC.EccKey.has_private()：用于检查 ECC 密钥对是否包含私钥。如果密钥对包含私钥，则返回 True；否则，返回 False。 

• ECC.generate(**kwargs)：generate() 函数用于生成一个新的 ECC 密钥对。可以通过关键字参数来指定生成密钥对的方式和参数，返回EccKey对象

curve：指定要使用的椭圆曲线，可以是一个 ECC.Curve 对象或椭圆曲线的名称。

entropy：指定用于生成密钥对的熵（随机性），可以是一个字节串或一个可调用对象。

randfunc：指定用于生成随机数的函数。默认情况下，使用系统提供的随机数生成函数。 

• ECC.construct(**kwargs)：construct() 函数用于根据给定的参数构造一个 ECC 密钥对，返回EccKey对象

curve：指定要使用的椭圆曲线，可以是一个 ECC.Curve 对象或椭圆曲线的名称。

point：指定曲线上的一个点，可以是一个 ECC.Point 对象或表示点坐标的元组。 

• ECC.import_key(encoded, passphrase=None, curve_name=None)：import_key() 函数用于从给定的数据导入一个 ECC 密钥对，返回EccKey对象

encoded：表示要导入的密钥对的数据，可以是一个字节串或字符串。

passphrase（可选）：如果密钥对被密码保护，需要提供正确的密码短语才能成功导入密钥对。

curve_name（可选）：指定要使用的椭圆曲线的名称。

八、pycryptodome之Crypto.Random

提供了生成随机数的功能。可以使用其中的函数来生成伪随机数和强随机数。

• Crypto.Random.random：随机数

• random.choice(seq)：从给定的序列中随机选择一个元素并返回。

'''
sep：这可迭代的序列，例如列表、元组或字符串，然后从中随机选择一个元素并返回
'''

• random.sample(population, k)：从给定的总体中随机选择指定数量的唯一元素，并以列表形式返回。

'''
population：可迭代的总体作为参数，例如列表、元组或字符串，然后从中随机选择指定数量的唯一元素，并以列表形式返回。
k：指定返回数量
'''

• random.randint(a, b)：生成一个指定范围内的随机整数，范围包括a和b
• random.getrandbits(k)：生成一个k位的随机整数，并返回
• random.randrange(start, stop[, step])：从指定范围内按指定步长随机选择一个整数并返回

'''
start表示起始值（包含）
stop表示终止值（不包含）
step表示步长，默认为1
'''

• andom.shuffle(x)：随机打乱可变序列（例如列表），直接修改原始序列直接修改原始序列

• Crypto.Random.get_random_bytes(n)：生成一个包含n个随机字节的字节串
• Crypto.Random.getrandbits(k)：生成一个k位的随机整数==
• Crypto.Random.atfork()：在多线程环境中使用，用于重置随机数生成器的状态。这个函数会在fork子进程之前调用，以避免子进程继承父进程的随机数状态。

九、pycryptodome之Crypto.Util

提供了一些常用的工具函数。例如，可以使用其中的函数来进行字节串的编码、解码，进行填充操作等。

• Crypto.Util.Padding：提供了填充和去填充数据的函数。

• pad(data_to_pad, block_sizet style)：用于填充数据

'''
data_to_pad：要进行填充的数据，类型为字节串（bytes）。
block_size：数据块的长度，以字节为单位。填充后的数据长度将是 block_size 的整数倍。
style：填充的风格，可选值为 'pkcs7'、'iso7816'、'x923'、'iso10126'、'zero' 或 None。默认值为 'pkcs7'。

None：不进行填充，如果数据长度不是块长度的整数倍，则会引发 ValueError 异常。
'''

• unpad(added_data, block_size style)：用于去除填充

padded_data：已填充的数据，类型为字节串（bytes）。
block_size：数据块的长度，以字节为单位。
style：填充的风格，与 pad() 函数中的风格参数相同。默认值为 'pkcs7'。

• Crypto.Util.number：提供了处理大整数的函数，例如生成随机素数、计算模反元素等。

• number.inverse(x, m)：计算模 m 下 x 的乘法逆元。返回值为 x 在模 m 下的乘法逆元。
• number.size(x)：返回整数 x 的字节大小。
• number.GCD(a, b)：计算整数 a 和 b 的最大公约数（Greatest Common Divisor，GCD）。返回值为 a 和 b 的最大公约数。
• number.bytes_to_long(s)：将字节串 s 转换为对应的长整数。
• number.long_to_bytes(n, blocksize)：将长整数 n 转换为字节串，其中 blocksize 指定了输出的字节块大小。
• number.ceil_div(a, b)：计算整数 a 除以整数 b 的向上取整除法结果。
• number.getPrime(N, randfunc=None)：生成一个 N 位的素数。可选参数 randfunc 是一个随机数生成函数，用于生成随机数。
• number.getRandomInteger(N, randfunc=None)：生成一个 N 位的随机整数。可选参数 randfunc 是一个随机数生成函数，用于生成随机数。
• number.getRandomNBitInteger(N, randfunc=None)：生成一个 N 位的随机整数。可选参数 randfunc 是一个随机数生成函数，用于生成随机数。
• number.getRandomRange(start, stop, randfunc=None)：生成一个在范围 [start, stop) 内的随机整数。可选参数 randfunc 是一个随机数生成函数，用于生成随机数。
• number.getStrongPrime(N, e, randfunc=None)：生成一个 N 位的强素数，其中 e 是公共指数。可选参数 randfunc 是一个随机数生成函数，用于生成随机数。
• number.isPrime(n, k=10)：检查整数 n 是否为素数。可选参数 k 指定了进行 Miller-Rabin 素性测试的次数。
• number.long2str(n)：将长整数 n 转换为字节串。
• number.str2long(s)：将字节串 s 转换为长整数。

• Crypto.Util.py3compat：提供了与 Python 2 和 Python 3 兼容性相关的函数和类。

• py3compat.bord(x)：将字节或字符 x 转换为对应的整数值。在 Python 2 中，x 可以是一个字符或字节；在 Python 3 中，x 必须是一个整数。
• py3compat.bchr(x)：将整数 x 转换为对应的字节或字符。在 Python 2 中，返回一个字符；在 Python 3 中，返回一个字节。
• py3compat.tobytes(x)：将输入 x 转换为字节串。在 Python 2 中，x 可以是一个字符串或字节串；在 Python 3 中，x 必须是一个字符串。
• py3compat.b(x)：将输入 x 转换为字节串。在 Python 2 中，返回输入 x 本身；在 Python 3 中，如果 x 是字符串，则返回其对应的字节串。
• py3compat.BytesIO()：创建一个类似于文件对象的字节串缓冲区。在 Python 2 和 Python 3 中都可用。
• py3compat.bytestring(x)：将输入 x 转换为字节串。在 Python 2 中，x 可以是一个字符串或字节串；在 Python 3 中，x 必须是一个字符串。
• py3compat.is_bytes(x)：检查输入 x 是否为字节串。在 Python 2 和 Python 3 中都可用。
• py3compat.is_native_int(x)：检查输入 x 是否为本机整数类型。在 Python 2 和 Python 3 中都可用。
• py3compat.is_string(x)：检查输入 x 是否为字符串类型。在 Python 2 和 Python 3 中都可用。
• py3compat.StringIO()：创建一个类似于文件对象的字符串缓冲区。在 Python 2 和 Python 3 中都可用。
• py3compat.tostr(x)：将输入 x 转换为字符串。在 Python 2 中，x 可以是一个字符串或字节串；在 Python 3 中，x 必须是一个字符串。

十、pycryptodome之Crypto.Protocol

提供了一些密码学协议的实现。例如，可以使用其中的类来进行密钥交换、安全通信等。

• Crypto.Protocol.SecretSharing：秘密共享，通过将秘密分割成多个部分（份额），可以将其分发给不同的参与者。只有在达到指定的阈值份额时，才能恢复原始的秘密。这对于实现安全的多方协议和数据保护非常有用。

• SecretSharing.Shamir.split(k,n,secret,ssss)：分割秘密

k：一个整数，表示恢复秘密所需的最小份额数。

n：一个整数，表示生成的总份额数。

secret：一个字节串，表示要分割的原始秘密，16字节。

ssss：一个整数，表示生成份额时使用的随机数种子 

• SecretSharing.Shamir.combine(shares,ssss)：恢复秘密

'''
shares：一个包含份额的列表。
ssss：一个整数，表示生成份额时使用的随机数种子。
'''
from Crypto.Protocol.SecretSharing import Shamir

k = 3  # 恢复秘密所需的最小份额数
n = 5  # 生成的总份额数
secret = b"Hello,Word!!!!!!"  # 要分割的原始秘密

shares = Shamir.split(k, n, secret) #分割秘密
print("生成的份额：", shares)

recovered_secret = Shamir.combine(shares[:k]) # 组合份额恢复秘密
print("恢复的秘密：", recovered_secret)

• Crypto.Protocol.KDF：密钥派生，密钥派生函数可以从一个输入密钥派生出更长或更复杂的密钥，以供加密、认证或其他密码学操作使用。

• KDF.HKDF(master, key_len, salts, hashmod, num_keys, context)：基于 HMAC 的密钥派生函数（HKDF）的实现。它使用输入的主密钥（master）和其他可选参数来派生一个或多个密钥，返回一个包含派生密钥的列表。

master：一个字节串，作为主密钥。

key_len：一个整数，表示派生密钥的长度。

salts：一个字节串或一个列表，用于指定盐值。如果提供了多个盐值，则会使用每个盐值进行密钥派生，并将结果连接在一起。

hashmod：一个哈希模块，例如 Crypto.Hash.SHA256。

num_keys：一个整数，表示要派生的密钥个数。

context：一个字节串，用于提供上下文信息。 

• KDF.scrypt(password, salt, key_len, N, r, p, num_keys)：基于密码派生函数的实现。它使用密码和盐值作为输入，并使用一组参数来派生一个或多个密钥，返回一个包含派生密钥的列表。

password：一个字节串，作为密码。

salt：一个字节串，作为盐值。

key_len：一个整数，表示派生密钥的长度。

N：一个整数，表示 scrypt 的 CPU/内存成本因子。

r：一个整数，表示 scrypt 的块大小。

p：一个整数，表示 scrypt 的并行化因子。

num_keys：一个整数，表示要派生的密钥个数。 

• KDF.bcrypt(password, cost, salt)：bcrypt 密码哈希函数的实现。它使用密码和盐值作为输入，并使用指定的计算成本（cost）来计算哈希值，返回一个包含 bcrypt 哈希值的字节串

password：一个字节串，作为密码。

cost：一个整数，表示计算成本，即计算哈希值所需的时间和资源。

salt：一个字节串，作为盐值。 

• KDF.bcrypt_check(password, bcrypt_hash)：验证 bcrypt 哈希值的函数。它使用密码和存储的 bcrypt 哈希值作为输入，并返回一个布尔值，指示密码是否匹配存储的哈希值，返回一个布尔值，指示密码是否匹配存储的哈希值。

password：一个字节串，作为密码。

bcrypt_hash：一个字节串，作为存储的 bcrypt 哈希值。 

• KDF.PBKDF1(password, salt, dkLen, count, hashAlgo)：PBKDF1 密码基于密码派生函数的实现。它使用密码和盐值作为输入，并使用指定的哈希算法和迭代次数来派生密钥，返回一个包含派生密钥的字节串。

password：一个字节串，作为密码。

salt：一个字节串，作为盐值。

dkLen：一个整数，表示派生密钥的长度。

count：一个整数，表示迭代次数。

hashAlgo：一个哈希算法模块，例如 Crypto.Hash.SHA256。 

• KDF.PBKDF2(password, salt, dkLen, count, prf, hmac_hash_module)：BKDF2 密码基于密码派生函数的实现。它使用密码和盐值作为输入，并使用指定的伪随机函数（PRF）和迭代次数来派生密钥，返回一个包含派生密钥的字节串。

password：一个字节串，作为密码。

salt：一个字节串，作为盐值。

dkLen：一个整数，表示派生密钥的长度。

count：一个整数，表示迭代次数。

prf：一个 PRF 对象，例如 Crypto.Protocol.KDF.PRF。

hmac_hash_module：一个哈希算法模块，例如 Crypto.Hash.SHA256。 

• KDF.SP800_108_Counter(master, key_len, prf, num_keys, label, context)：使用 SP800-108 密钥派生函数派生密钥

  master：主密钥。

master：主密钥。

key_len：派生密钥的长度（以字节为单位）。

prf：伪随机函数。

num_keys：要派生的密钥数量。

label：标签。

context：上下文数据（可选参数）。

十一、pycryptodome之Crypto.Math

提供了一些密码学相关的数学函数和算法的实现。例如，可以使用其中的类来进行大数运算、素数生成和验证等。

• Crypto.Math.Primality：素数相关数学函数

• generate_probable_prime(exact_bits, randfunc, prime_filter)：用于生成一个指定位数的可能素数

exact_bits：生成素数的位数。

randfunc：一个随机数生成函数，用于生成随机数。

prime_filter：一个可选的函数，用于过滤掉不符合特定条件的候选素数。 

• generate_probable_safe_prime(exact_bits, randfunc)：用于生成一个指定位数的可能安全素数

exact_bits：生成素数的位数。

randfunc：一个随机数生成函数，用于生成随机数。 

• Crypto.Math.Numbers：数字相关数学函数

• numbers = Numbers.Integer(2)：创建Numbers对象
• numbers.ize_in_bytes()：返回整数的字节大小。
• numbers.size_in_bits()：返回整数的位数。
• numbers.set(source)：将整数设置为给定的值。
• numbers.random(**kwargs)：生成一个随机的整数。
• numbers.random_range(**kwargs)：生成一个指定范围内的随机整数。
• numbers.sqrt(modulus)：计算整数的平方根模 modulus。
• numbers.lcm(term)：计算整数与给定项 term 的最小公倍数。
• numbers.gcd(term)：计算整数与给定项 term 的最大公约数。
• numbers.fail_if_divisible_by(small_prime)：如果整数可以被给定的小质数 small_prime 整除，则引发异常。
• nu编程客栈mbers.from_bytes(byte_string, byteorder)：将字节字符串转换为整数。
• numbers.get_bit()：返回整数的最低有效位。
• numbers.inplace_inverse(modulus)：计算整数在模 modulus 下的乘法逆元并修改原始整数。
• numbers.inverse(modulus)：计算整数在模 modulus 下的乘法逆元。
• numbers.is_odd()：检查整数是否为奇数。
• numbers.is_even()：检查整数是否为偶数。
• numbers.inplace_pow(exponent, modulus)：计算整数的幂次方并修改原始整数。
• numbers.is_negative()：检查整数是否为负数。
• numbers.is_perfect_square()：检查整数是否为完全平方数。

到此这篇关于python中pycryptodome模块实现加密算法库的文章就介绍到这了,更多相关python pycryptodome加密内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！