python之pycryptodome模块，加密算法库

一、简介

PyCryptodome是PyCrypto库的一个分支，它是Python中最受欢迎的密码学库之一。PyCryptodome提供了许多密码学算法和协议的实现，包括对称加密、非对称加密、消息摘要、密码哈希、数字签名等。它还提供了一些其他功能，如密码学安全随机数生成、密码学文件格式的支持等。PyCryptodome的设计目标是提供高性能和可移植性。
如果你需要更高的性能和可移植性，那么PyCryptodome可能更适合你。如果你注重安全性和易用性，并且希望遵循最佳实践，那么Cryptography可能是一个不错的选择。

二、安装

pip install pycryptodome

三、pycryptodome之Crypto.Cipher

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

1. 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模式是一种认证加密模式，它提供了加密、解密和消息完整性验证的功能，并允许使用相同的密钥对多个消息进行加密，而不会泄漏关于明文的信息。

2. 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 是一种认证加密模式，同时提供加密和认证功能。

3. 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。当加密器对象的缓冲区中的数据被消耗完之后，会自动重新生成新的密钥流并填充缓冲区。

4. 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 加密算法的电子密码本模式。在该模式下，每个明文分组都会独立地进行加密。

5. 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 加密算法的密码反馈模式。在该模式下，明文分组的一部分会被加密，然后与明文分组的下一部分进行异或运算。

6. 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 字节。

8. 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_plaintext)  # 加密

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 模式下，每个明文分组先与前一个密文分组进行异或运算，然后再进行加密。

9. 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)：用于调整密钥的奇偶校验位，确保密钥的正确性。

10. 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 加密器和解密器对象时，可以将其用作哈希算法的参数类型。

11. 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 加密器和解密器对象时，可以将其用作明文和密文的参数类型。

12. 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())

2. 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())

3. 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())

4. 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())

5. 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())

6. 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())

7. 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())

8. 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())

9. 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())

10. 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())

11. 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())

12. 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.Hash 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())

13. 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))

14. 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))

15. 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()))

16. 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())

17. 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())

18. 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()))

19. 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()))

20. 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())

21. 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())

22. 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())

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

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

'''
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())

24. 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))

25. 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

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

1. 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)

2. 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

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

1. 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))

2. 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))

3. 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等。

1. 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 是密钥的密码（如果有的话）。

2. 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 是一个布尔值，表示是否进行一致性检查。

3. 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（私钥）等。

4. 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

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

1. 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)：随机打乱可变序列（例如列表），直接修改原始序列直接修改原始序列

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

九、pycryptodome之Crypto.Util

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

1. 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'。

2. 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 转换为长整数。

3. 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

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

1. 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)

2. 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

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

1. 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：一个随机数生成函数，用于生成随机数。

2. 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 整除，则引发异常。
• numbers.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()：检查整数是否为完全平方数。