一、簡介

PyCryptodome是PyCrypto庫的一個分支，它是Python中最受歡迎的密碼學庫之一。PyCryptodome提供了許多密碼學算法和協(xié)議的實現(xiàn)，包括對稱加密、非對稱加密、消息摘要、密碼哈希、數(shù)字簽名等。它還提供了一些其他功能，如密碼學安全隨機數(shù)生成、密碼學文件格式的支持等。PyCryptodome的設計目標是提供高性能和可移植性。
如果你需要更高的性能和可移植性，那么PyCryptodome可能更適合你。如果你注重安全性和易用性，并且希望遵循最佳實踐，那么Cryptography可能是一個不錯的選擇。

二、安裝

pip install pycryptodome

三、pycryptodome之Crypto.Cipher

提供了對稱加密算法的實現(xiàn)。可以使用其中的類來創(chuàng)建加密器和解密器，支持常見的對稱加密算法，如AES、DES、Triple DES等。

• Crypto.Cipher.AES：對稱加密算法，支持不同的密鑰長度（128位、192位和256位）。它是目前廣泛使用的加密算法之一。

• AES.new(key, mode, use_aesni)：創(chuàng)建一個AES加密器/解密器對象

'''
key：表示用于加密和解密的密鑰。它應該是一個字節(jié)串（bytes）類型，長度可以是16、24或32字節(jié)，對應于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字節(jié)密鑰

plaintext = b'Hello, world!' #加密數(shù)據(jù)

cipher = AES.new(key, AES.MODE_ECB) # 創(chuàng)建 AES 加密器對象
padded_plaintext = pad(plaintext, AES.block_size)  # 填充明文數(shù)據(jù)

ciphertext = cipher.encrypt(padded_plaintext)# 加密

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

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• AES.block_size：表示AES算法的塊大小（以字節(jié)為單位），通常為16字節(jié)。
• AES.key_size：表示AES算法支持的密鑰長度（以字節(jié)為單位），可以是16、24或32字節(jié)。
• AES.Buffer：表示用于加密和解密操作的緩沖區(qū)大小（以字節(jié)為單位）。
• AES.MODE_ECB：電子密碼本模式，將每個明文塊獨立地加密成相應的密文塊。ECB模式不提供加密的完全安全性，因為相同的明文塊將始終加密成相同的密文塊。
• AES.MODE_CBC：在CBC模式中，每個明文塊會與前一個密文塊進行異或操作，然后再進行加密。需要一個初始向量（IV）來開始加密過程。
• AES.MODE_CCM：CCM模式是一種組合模式，它將CTR模式和CBC-MAC（密碼分組鏈接消息認證碼）組合在一起。它提供了加密、解密和消息完整性驗證的功能。
• AES.MODE_CFB：CFB模式將前一個密文塊作為密鑰流的一部分，然后與明文進行異或操作，產(chǎn)生密文。類似于CBC模式，需要一個初始向量（IV）。
• AES.MODE_CTR：CTR模式中，明文與一個計數(shù)器進行異或操作，生成密文。計數(shù)器可以是遞增的，也可以是隨機的，只要在加密和解密過程中保持一致即可。
• AES.MODE_EAX：EAX模式是一種組合模式，它將CTR模式和CMAC（密碼分組鏈接消息認證碼）組合在一起。它提供了加密、解密和消息完整性驗證的功能。
• AES.MODE_GCM：GCM模式是一種組合模式，它將CTR模式和GMAC（Galois消息認證碼）組合在一起。它提供了加密、解密和消息完整性驗證的功能。
• AES.MODE_OCB：OCB模式是一種組合模式，它將CTR模式和CMAC組合在一起，并引入了一種效率更高的計算方式。它提供了加密、解密和消息完整性驗證的功能。
• AES.MODE_OFB：OFB模式將前一個密文塊作為密鑰流的一部分，然后與明文進行異或操作，產(chǎn)生密文。類似于CFB模式，不需要初始向量（IV）。
• AES.MODE_OPENPGP）：OpenPGP模式是一種擴展的加密模式，用于與OpenPGP協(xié)議兼容的系統(tǒng)。
• AES.MODE_SIV：SIV模式是一種認證加密模式，它提供了加密、解密和消息完整性驗證的功能，并允許使用相同的密鑰對多個消息進行加密，而不會泄漏關于明文的信息。

• Crypto.Cipher.ARC2：對稱加密算法，密鑰長度可變，通常為40位。它是一種較舊的加密算法，現(xiàn)在很少使用。

• ARC2.new(key,mode,iv,IV,nonce,segment_size,mac_len, initial_value,counter)：創(chuàng)建一個ARC2加密器/解密器對象

'''
key：ARC2 加密算法使用的密鑰。它應該是一個字節(jié)字符串，并且長度必須在 1 到 128 字節(jié)之間（包括邊界值）。
mode：指定 ARC2 加密模式?？梢允褂靡韵鲁Ａ恐唬?
iv或IV：初始化向量 (Initialization Vector)，用于在加密過程中引入隨機性。它應該是一個字節(jié)字符串，并且長度必須與算法的塊大小相同。在某些模式下，如 ECB 模式，iv 參數(shù)可以被忽略。
nonce：用于計數(shù)器模式的隨機數(shù)。它應該是一個字節(jié)字符串，并且長度必須與算法的塊大小相同。
segment_size：在 CFB 模式中，指定數(shù)據(jù)分段的大?。ㄒ晕粸閱挝唬ＤJ值為 8。
mac_len：在 EAX 模式中，指定消息認證碼 (MAC) 的長度（以字節(jié)為單位）。默認值為 16。
initial_value：在計數(shù)器模式中，指定初始計數(shù)器值。它應該是一個整數(shù)。默認值為 0。
counter：在計數(shù)器模式中，指定計數(shù)器對象。它應該是一個 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!"  # 要加密的數(shù)據(jù)

cipher = ARC2.new(key, ARC2.MODE_CBC)  # 創(chuàng)建 ARC2 加密器對象
padded_data = pad(plaintext, cipher.block_size)  # 對數(shù)據(jù)進行填充
ciphertext = cipher.encrypt(padded_data)  # 加密數(shù)據(jù)

decipher = ARC2.new(key, ARC2.MODE_CBC,cipher.iv)  # 創(chuàng)建 ARC2 加密器對象
decrypted = decipher.decrypt(ciphertext)  # 解密數(shù)據(jù)
decrypted_data = unpad(decrypted, cipher.block_size) # 去除填充

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• ARC2.block_size：ARC2 算法的塊大小，以字節(jié)為單位。在 pycryptodome 中，ARC2 的塊大小為 8 字節(jié)。
• ARC2.key_size：ARC2 算法支持的密鑰長度，以字節(jié)為單位。在 pycryptodome 中，ARC2 的密鑰長度可以在 1 到 128 字節(jié)之間。
• ARC2.Buffer：在 pycryptodome 中，ARC2 加密器對象的內部緩沖區(qū)。
• ARC2.MODE_ECB：電子密碼本模式。在 ECB 模式下，每個塊獨立地進行加密或解密，沒有引入隨機性。
• ARC2.MODE_CBC：密碼分組鏈接模式 。在 CBC 模式下，每個塊的加密依賴于前一個塊的密文，引入了隨機性。
• ARC2.MODE_CFB：密碼反饋模式 。在 CFB 模式下，每個塊的加密依賴于前一個塊的密文和密鑰流，引入了隨機性。
• ARC2.MODE_OFB：輸出反饋模式。在 OFB 模式下，每個塊的加密依賴于前一個塊的密鑰流，引入了隨ChaCha20機性。
• ARC2.MODE_CTR：計數(shù)器模式。在 CTR 模式下，每個塊的加密依賴于計數(shù)器值和密鑰流，引入了隨機性。
• ARC2.MODE_OPENPGP：OpenPGP 模式。在 OpenPGP 模式下，使用了特定的密鑰派生函數(shù)和密鑰流生成算法。
• ARC2.MODE_EAX：EAX 模式。EAX 是一種認證加密模式，同時提供加密和認證功能。

• Crypto.Cipher.ARC4：對稱加密算法，也被稱為RC4。它是一種流密碼算法，密鑰長度可變。它簡單高效，但由于一些安全性問題，現(xiàn)在不推薦使用。

• ARC4.new(key,drop)：創(chuàng)建一個ARC4加密器/解密器對象

'''
key：表示要使用的密鑰。密鑰是一個字節(jié)串（bytes），長度可以根據(jù)需要進行調整。通常情況下，密鑰的長度應該與算法要求的密鑰長度相匹配。
drop：表示在生成初始密鑰流之前要丟棄的初始字節(jié)數(shù)。這個參數(shù)是可選的，默認值為 0。在某些應用中，可以選擇在開始加密之前丟棄一些初始字節(jié)，以增加密鑰流的隨機性。
'''
from Crypto.Cipher import ARC4
from Crypto.Random import get_random_bytes

key = get_random_bytes(16)  # 生成隨機密鑰
plaintext = b"Hello, world!"  # 要加密的數(shù)據(jù)

cipher = ARC4.new(key)  # 創(chuàng)建 ARC4 加密器對象
ciphertext = cipher.encrypt(plaintext)  # 加密數(shù)據(jù)

decipher = ARC4.new(key)  # 創(chuàng)建 ARC4 解密器對象
decrypted_data = decipher.decrypt(ciphertext)  # 解密數(shù)據(jù)

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• ARC4.block_size：加密算法的塊大小。對于 RC4 算法而言，它是一個流密碼算法，沒有固定的塊大小，因此 block_size 的值為 1。
• ARC4.key_size：加密算法支持的密鑰長度。對于 RC4 算法而言，密鑰可以是任意長度的字節(jié)串，因此 key_size 的值為可變的，沒有固定的長度限制。
• ARC4.Buffer：RC4 算法內部使用的緩沖區(qū)大小。在 pycryptodome 中，這個值默認為 4096。當加密器對象的緩沖區(qū)中的數(shù)據(jù)被消耗完之后，會自動重新生成新的密鑰流并填充緩沖區(qū)。

• Crypto.Cipher.Blowfish：對稱加密算法，密鑰長度可變。它是一種快速且安全的加密算法，適用于各種應用場景。

• Blowfish.new(key,mode,iv,IV,nonce,segment_size,mac_len ,initial_value,counter) ：創(chuàng)建一個Blowfish加密器/解密器對象

'''
key：表示要使用的密鑰。密鑰是一個字節(jié)串（bytes），長度可以根據(jù)需要進行調整。Blowfish 算法支持的密鑰長度可以是 8 到 448 位之間的任意長度。
mode：表示加密模式。這個參數(shù)是可選的，默認值為 MODE_ECB，表示使用電子密碼本模式。其他可選的模式包括 MODE_CBC（密碼分組鏈接模式）和 MODE_CFB（密碼反饋模式）等。
iv 或 IV：表示初始化向量。這個參數(shù)是可選的，用于在加密過程中增加隨機性。對于 ECB 模式，不需要提供初始化向量；對于其他模式，通常需要提供一個與塊大小相匹配的初始化向量。
nonce：表示使用的隨機數(shù)。這個參數(shù)是可選的，用于在加密過程中增加隨機性。通常與 CTR 模式一起使用。
segment_size：表示 CFB 模式中的分段大小。這個參數(shù)是可選的，默認值為 8。在 CFB 模式中，明文被分成固定大小的分段進行加密。
mac_len：表示消息認證碼的長度。這個參數(shù)是可選的，默認值為 None，表示不使用消息認證碼。
initial_value：表示初始值。這個參數(shù)是可選的，用于在某些模式下設置初始值。
counter：表示計數(shù)器的初始值。這個參數(shù)是可選的，用于在 CTR 模式下設置計數(shù)器的初始值。
'''
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!"  # 要加密的明文

# 創(chuàng)建 Blowfish 加密器對象，使用 CBC 模式和隨機的初始化向量
cipher = Blowfish.new(key, mode=Blowfish.MODE_CBC, iv=get_random_bytes(8))
padded_plaintext = pad(plaintext, cipher.block_size)  # 填充明文數(shù)據(jù)
ciphertext = cipher.encrypt(padded_plaintext)  # 加密明文

decipher = Blowfish.new(key, mode=Blowfish.MODE_CBC, iv=cipher.iv)  # 創(chuàng)建 Blowfish 加密器對象
decrypted = decipher.decrypt(ciphertext)  # 解密數(shù)據(jù)
decrypted_data = unpad(decrypted, cipher.block_size)  # 去除填充

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• Blowfish.block_size：Blowfish 算法的分組大小（以字節(jié)為單位）。對于 Blowfish 算法，分組大小固定為 8 字節(jié)。
• Blowfish.Buffer：Blowfish 加密器對象的內部緩沖區(qū)的大?。ㄒ宰止?jié)為單位）。在 pycryptodome 中，默認的緩沖區(qū)大小為 4096 字節(jié)。
• Blowfish.key_size：Blowfish 算法支持的密鑰長度（以位為單位）。對于 Blowfish 算法，密鑰長度可以是 32 到 448 位之間的任意長度。
• Blowfish.MODE_CBC：Blowfish 加密算法的密碼分組鏈接模式。在該模式下，每個明文分組在加密之前會與前一個密文分組進行異或運算。
• Blowfish.MODE_CFB：Blowfish 加密算法的密碼反饋模式。在該模式下，明文分組的一部分會被加密，然后與明文分組的下一部分進行異或運算。
• Blowfish.MODE_CTR：Blowfish 加密算法的計數(shù)器模式。在該模式下，明文分組會與計數(shù)器進行加密，計數(shù)器的值會根據(jù)分組的索引逐漸遞增。
• Blowfish.MODE_EAX：Blowfish 加密算法的 EAX 模式。在該模式下，可以同時進行加密和消息認證，并提供附加數(shù)據(jù)的完整性驗證。
• Blowfish.MODE_OFB：Blowfish 加密算法的輸出反饋模式。在該模式下，密鑰流會被生成并與明文分組進行異或運算，然后輸出密文。
• Blowfish.MODE_OPENPGP：Blowfish 加密算法的 OpenPGP 模式。該模式與 CFB 模式類似，但使用了不同的填充和反饋函數(shù)。
• Blowfish.MODE_ECB：Blowfish 加密算法的電子密碼本模式。在該模式下，每個明文分組都會獨立地進行加密。

• Crypto.Cipher.CAST：對稱加密算法，密鑰長度可變。它是一種安全性較高的加密算法，適用于各種應用場景。

• CAST.new(key,mode,iv,IV,nonce,segment_size,mac_len ,initial_value,counter)：創(chuàng)建一個CAST加密器/解密器對象

'''
key：要使用的密鑰。密鑰是一個字節(jié)串（bytes），長度可以是 5 到 16 字節(jié)之間的任意長度。
mode：加密模式。可以使用以下常量來指定加密模式：
iv 或 IV：初始化向量（Initialization Vector）。初始化向量是一個字節(jié)串（bytes），長度固定為 8 字節(jié)。在某些加密模式下，如 CBC、CFB 和 OFB，需要提供一個初始化向量。
nonce：使用的隨機數(shù)。這個參數(shù)是一個字節(jié)串（bytes），長度通常為 8 字節(jié)。在 CTR 模式下，需要提供一個隨機的 nonce。
segment_size：分段大小（以字節(jié)為單位）。在 CFB 模式下，可以指定分段大小，取值范圍為 1 到 8 之間的整數(shù)。
mac_len：消息認證碼的長度（以字節(jié)為單位）。在 CCM 和 EAX 模式下，可以指定消息認證碼的長度。
initial_value：初始值。在 CTR 模式下，可以指定初始值。
counter：計數(shù)器的初始值。在 CTR 模式下，可以指定計數(shù)器的初始值。
'''
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!"  # 要加密的明文

# 創(chuàng)建 CAST 加密器對象，使用 CBC 模式和隨機的初始化向量
cipher = CAST.new(key, mode=CAST.MODE_CBC, iv=get_random_bytes(8))
padded_plaintext = pad(plaintext, cipher.block_size)  # 填充明文數(shù)據(jù)
ciphertext = cipher.encrypt(padded_plaintext)  # 加密明文

decipher = CAST.new(key, mode=CAST.MODE_CBC, iv=cipher.iv)  # 創(chuàng)建 CAST 加密器對象
decrypted = decipher.decrypt(ciphertext)  # 解密數(shù)據(jù)
decrypted_data = unpad(decrypted, cipher.block_size)  # 去除填充

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• CAST.block_size：CAST 算法的分組大小（以字節(jié)為單位）。對于 CAST 算法，分組大小固定為 8 字節(jié)。
• CAST.key_size：CAST 算法支持的密鑰長度（以位為單位）。對于 CAST 算法，密鑰長度可以是 40 位到 128 位之間的任意長度。
• CAST.Buffer：CAST 加密器對象的內部緩沖區(qū)的大?。ㄒ宰止?jié)為單位）。在 pycryptodome 中，默認的緩沖區(qū)大小為 4096 字節(jié)。
• CAST.MODE_CBC：CAST 加密算法的密碼分組鏈接模式。在該模式下，每個明文分組在加密之前會與前一個密文分組進行異或運算。
• CAST.MODE_ECB：CAST 加密算法的電子密碼本模式。在該模式下，每個明文分組都會獨立地進行加密。
• CAST.MODE_OPENPGP：CAST 加密算法的 OpenPGP 模式。該模式與 CFB 模式類似，但使用了不同的填充和反饋函數(shù)。
• CAST.MODE_OFB：CAST 加密算法的輸出反饋模式。在該模式下，密鑰流會被生成并與明文分組進行異或運算，然后輸出密文。
• CAST.MODE_EAX：CAST 加密算法的 EAX 模式。在該模式下，可以同時進行加密和消息認證，并提供附加數(shù)據(jù)的完整性驗證。
• CAST.MODE_CTR：CAST 加密算法的計數(shù)器模式。在該模式下，明文分組會與計數(shù)器進行加密，計數(shù)器的值會根據(jù)分組的索引逐漸遞增。
• CAST.MODE_CFB：CAST 加密算法的密碼反饋模式。在該模式下，明文分組的一部分會被加密，然后與明文分組的下一部分進行異或運算。

• Crypto.Cipher.ChaCha20：對稱加密算法，密鑰長度為256位。它是一種高速的加密算法，適用于資源受限的環(huán)境。

• ChaCha20.new(key,nonce)：創(chuàng)建一個ChaCha20加密器/解密器對象

'''
key：要使用的密鑰。密鑰是一個字節(jié)串（bytes），長度固定為 32 字節(jié)。
nonce：使用的隨機數(shù)。這個參數(shù)是一個字節(jié)串（bytes），長度可以是 8 字節(jié)或 12 字節(jié)。
'''
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)# 創(chuàng)建 ChaCha20 加密器對象
plaintext = b"Hello, World!"# 要加密的明文
ciphertext = cipher.encrypt(plaintext) # 加密明文

decrypt_cipher = ChaCha20.new(key=key, nonce=nonce) # 創(chuàng)建新的 ChaCha20 加密器對象，使用相同的密鑰和 nonce
decrypted_data = decrypt_cipher.decrypt(ciphertext) # 解密密文

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• ChaCha20.block_size：ChaCha20 算法的分組大?。ㄒ宰止?jié)為單位）。對于 ChaCha20 算法，分組大小固定為 64 字節(jié)。
• ChaCha20.key_size：ChaCha20 算法支持的密鑰長度（以位為單位）。對于 ChaCha20 算法，密鑰長度固定為 256 位。
• ChaCha20.Buffer：ChaCha20 加密器對象的內部緩沖區(qū)的大?。ㄒ宰止?jié)為單位）。在 pycryptodome 中，默認的緩沖區(qū)大小為 4096 字節(jié)
  7.Crypto.Cipher.ChaCha20_Poly1305：對稱加密算法，結合了ChaCha20和Poly1305消息認證碼。它提供了高速的加密和完整性保護。
• ChaCha20_Poly1305.new(key,nonce)：創(chuàng)建一個ChaCha20_Poly1305加密器/解密器對象

'''
key：要使用的密鑰。密鑰是一個字節(jié)串（bytes），長度固定為 32 字節(jié)。
nonce：使用的隨機數(shù)。這個參數(shù)是一個字節(jié)串（bytes），長度可以是 8 字節(jié)或 12 字節(jié)。
'''
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)# 創(chuàng)建 ChaCha20 加密器對象
plaintext = b"Hello, World!"# 要加密的明文
ciphertext = cipher.encrypt(plaintext) # 加密明文

decrypt_cipher = ChaCha20_Poly1305.new(key=key, nonce=nonce) # 創(chuàng)建新的 ChaCha20 加密器對象，使用相同的密鑰和 nonce
decrypted_data = decrypt_cipher.decrypt(ciphertext) # 解密密文

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• ChaCha20_Poly1305.block_size：ChaCha20_Poly1305 算法的分組大小（以字節(jié)為單位）。對于 ChaCha20_Poly1305 算法，分組大小固定為 64 字節(jié)。
• ChaCha20_Poly1305.key_size：ChaCha20_Poly1305 算法支持的密鑰長度（以位為單位）。對于 ChaCha20_Poly1305 算法，密鑰長度固定為 256 位。
• ChaCha20_Poly1305.Buffer：ChaCha20_Poly1305 加密器對象的內部緩沖區(qū)的大小（以字節(jié)為單位）。在 pycryptodome 中，默認的緩沖區(qū)大小為 4096 字節(jié)。

• Crypto.Cipher.DES：對稱加密算法，密鑰長度為56位。它是一種較舊的加密算法，現(xiàn)在不推薦使用。

• DES.new(key,mode,iv,IV,nonce,segment_size,mac_len ,initial_value,counter)：創(chuàng)建一個DES加密器/解密器對象

'''
key：要使用的密鑰。密鑰是一個字節(jié)串（bytes），長度固定為 8 字節(jié)。
mode：加密模式。可以使用以下常量來指定加密模式：
iv 或 IV：初始化向量（Initialization Vector）。初始化向量是一個字節(jié)串（bytes），長度固定為 8 字節(jié)。在某些加密模式下，如 CBC、CFB 和 OFB，需要提供一個初始化向量。
nonce：使用的隨機數(shù)。這個參數(shù)是一個字節(jié)串（bytes），長度通常為 8 字節(jié)。在 CTR 模式下，需要提供一個隨機的 nonce。
segment_size：分段大小（以字節(jié)為單位）。在 CFB 模式下，可以指定分段大小，取值范圍為 1 到 8 之間的整數(shù)。
mac_len：消息認證碼的長度（以字節(jié)為單位）。在 CCM 和 EAX 模式下，可以指定消息認證碼的長度。
initial_value：初始值。在 CTR 模式下，可以指定初始值。
counter：計數(shù)器的初始值。在 CTR 模式下，可以指定計數(shù)器的初始值
'''
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字節(jié)密鑰

plaintext = b'Hello, world!'  # 加密數(shù)據(jù)

cipher = DES.new(key, DES.MODE_ECB)  # 創(chuàng)建 DES 加密器對象
padded_plaintext = pad(plaintext, DES.block_size)  # 填充明文數(shù)據(jù)

ciphertext = cipher.encrypt(padded_plaintext)  # 加密

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

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• DES.key_size：DES 加密算法支持的密鑰大?。ㄒ晕粸閱挝唬?。在 DES 中，密鑰大小固定為 56 位。
• DES.block_size：DES 加密算法的分組大?。ㄒ宰止?jié)為單位）。在 DES 中，分組大小固定為 8 字節(jié)。
• DES.MODE_ECB：DES 加密算法的電子密碼本模式（Electronic Codebook）。在 ECB 模式下，每個分組都獨立地進行加密，相同的明文分組將得到相同的密文分組。
• DES.MODE_CFB：DES 加密算法的密碼反饋模式（Cipher Feedback）。在 CFB 模式下，前一個密文分組被反饋給加密器，用于生成下一個密文分組。
• DES.MODE_CTR：DES 加密算法的計數(shù)器模式（Counter）。在 CTR 模式下，每個分組都使用一個唯一的計數(shù)器值進行加密，計數(shù)器值通過加密器生成。
• 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)：創(chuàng)建一個DES3加密器/解密器對象

'''
key：表示要使用的密鑰。密鑰是一個字節(jié)串（bytes），長度必須為 16 或 24 字節(jié)。
mode：表示加密模式?？梢允褂靡韵鲁Ａ窟M行指定：
iv 或 IV：表示初始化向量。這個參數(shù)是一個字節(jié)串（bytes），長度必須為 8 字節(jié)。
nonce：表示使用的隨機數(shù)。這個參數(shù)是一個字節(jié)串（bytes），長度必須為 8 字節(jié)。
segment_size：表示用于 CFB 模式的分段大小（以位為單位）。默認值為 8。
mac_len：表示 EAX 模式中認證標簽的長度（以字節(jié)為單位）。默認值為 8。
initial_value：表示 CTR 模式中初始計數(shù)器值。這個參數(shù)是一個整數(shù)，默認值為 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字節(jié)密鑰

plaintext = b'Hello, world!'  # 加密數(shù)據(jù)

cipher = DES3.new(key, DES3.MODE_ECB)  # 創(chuàng)建 DES3 加密器對象
padded_plaintext = pad(plaintext, cipher.block_size)  # 填充明文數(shù)據(jù)

ciphertext = cipher.encrypt(padded_plaintext)  # 加密

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

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted_data)

• DES3.block_size：DES3 加密算法的分組大小（以字節(jié)為單位）。在 DES3 中，分組大小固定為 8 字節(jié)。
• DES3.key_size：DES3 加密算法支持的密鑰大小（以位為單位）。在 DES3 中，密鑰大小可以是 128 位（16 字節(jié)）或 192 位（24 字節(jié)）。
• DES3.Buffer：DES3 加密算法的緩沖區(qū)大?。ㄒ宰止?jié)為單位）。
• 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 加密算法的計數(shù)器模式（Counter）。在 CTR 模式下，每個分組都使用一個唯一的計數(shù)器值進行加密，計數(shù)器值通過加密器生成。
• DES3.MODE_CFB：DES3 加密算法的密碼反饋模式（Cipher Feedback）。在 CFB 模式下，前一個密文分組被反饋給加密器，用于生成下一個密文分組。
• DES3.adjust_key_parity(key_in)：用于調整密鑰的奇偶校驗位，確保密鑰的正確性。

• Crypto.Cipher.PKCS1_OAEP：非對稱加密算法，使用OAEP（Optimal Asymmetric Encryption Padding）填充方案。它用于加密和解密數(shù)據(jù)，通常與RSA密鑰一起使用。

• PKCS1_OAEP.new(key,hashAlgo,mgfunc,label,randfunc)：創(chuàng)建一個PKCS1_OAEP加密器/解密器對象

'''
key：RSA 密鑰對象（公鑰或私鑰）。
hashAlgo：哈希算法，用于計算散列值?？梢允褂?Crypto.Hash 模塊中的哈希算法，例如 Crypto.Hash.SHA256。
mgfunc：掩碼生成函數(shù)（Mask Generation Function），用于生成掩碼以進行填充。默認為 None，表示使用標準的 MGF1。
label：可選參數(shù)，用于標識消息的標簽。默認為 b''。
randfunc：可選參數(shù)，用于生成隨機數(shù)。默認為 None，表示使用 Crypto.Random 模塊中的默認隨機數(shù)生成器。
'''
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!'  # 加密數(shù)據(jù)

cipher = PKCS1_OAEP.new(key, hashAlgo=SHA256)  # 創(chuàng)建 PKCS1_OAEP 加密器對象
ciphertext = cipher.encrypt(plaintext)  # 加密

decrypt_cipher = PKCS1_OAEP.new(key, hashAlgo=SHA256)  # 創(chuàng)建 PKCS1_OAEP 加密器對象
decrypted = decrypt_cipher.decrypt(ciphertext)  # 解密

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted)

• PKCS1_OAEP.Buffer 一個字節(jié)串（bytes）類型的緩沖區(qū)。在使用 PKCS1_OAEP 加密器和解密器對象時，可以將其用作密鑰、明文和密文的參數(shù)類型。
• PKCS1_OAEP.HashLike 一個類似于哈希對象的類型。在使用 PKCS1_OAEP 加密器和解密器對象時，可以將其用作哈希算法的參數(shù)類型。

• Crypto.Cipher.PKCS1_v1_5：非對稱加密算法，使用PKCS#1 v1.5填充方案。它用于加密和解密數(shù)據(jù)，通常與RSA密鑰一起使用。

• PKCS1_v1_5.new(key,randfunc)：創(chuàng)建一個PKCS1_v1_5加密器/解密器對象

'''
key：RSA 密鑰對象，可以是公鑰或私鑰。這個密鑰對象用于進行加密或解密操作。
randfunc：一個可調用對象，用于生成隨機數(shù)。如果提供了 randfunc，它將被用于生成加密過程中需要的隨機字節(jié)。如果未提供 randfunc，則會使用默認的隨機數(shù)生成器
'''
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5

key = RSA.generate(2048)  # 生成 RSA 密鑰對
plaintext = b'Hello, world!'  # 加密數(shù)據(jù)

cipher = PKCS1_v1_5.new(key)  # 創(chuàng)建 PKCS1_v1_5 加密器對象
ciphertext = cipher.encrypt(plaintext)  # 加密

decrypt_cipher = PKCS1_v1_5.new(key)  # 創(chuàng)建 PKCS1_v1_5 加密器對象
decrypted = decrypt_cipher.decrypt(ciphertext, None)  # 解密

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted)

• PKCS1_v1_5.Buffer 一個字節(jié)串（bytes）類型的緩沖區(qū)。在使用 PKCS1_v1_5 加密器和解密器對象時，可以將其用作明文和密文的參數(shù)類型。

• Crypto.Cipher.Salsa20：對稱加密算法，密鑰長度為256位。它是一種高速的加密算法，適用于資源受限的環(huán)境。

• Salsa20.new(key,nonce)：創(chuàng)建一個Salsa20加密器/解密器對象

'''
key：Salsa20 密鑰，一個字節(jié)串（bytes）類型的密鑰。密鑰長度可以是 16 字節(jié)（128 位）或 32 字節(jié)（256 位）。
nonce：Salsa20 隨機數(shù)，一個字節(jié)串（bytes）類型的隨機數(shù)。它用于與密鑰一起生成加密流。
'''

from Crypto.Cipher import Salsa20

key = b'0123456789abcdef'  # 16 字節(jié)密鑰
nonce = b'87654321'  # 8 字節(jié)隨機數(shù)

plaintext = b'Hello, world!'# 明文數(shù)據(jù)

cipher = Salsa20.new(key,nonce)  # 創(chuàng)建 Salsa20 加密器對象
ciphertext = cipher.encrypt(plaintext)  # 加密

decrypt_cipher = Salsa20.new(key,nonce)  # 創(chuàng)建 Salsa20 加密器對象
decrypted = decrypt_cipher.decrypt(ciphertext)  # 解密

print('原始數(shù)據(jù):', plaintext)
print('加密后:', ciphertext.hex())
print('解密后:', decrypted)

• Salsa20.Buffer：一個字節(jié)串（bytes）類型的緩沖區(qū)。它用于描述 Salsa20 加密器和解密器對象的參數(shù)類型。
• Salsa20.key_size：Salsa20 密鑰的長度，單位為字節(jié)。在 pycryptodome 中，Salsa20 密鑰長度可以是 16 字節(jié)（128 位）或 32 字節(jié)（256 位）。
• Salsa20.block_size：Salsa20 加密算法的塊大小，單位為字節(jié)。在 pycryptodome 中，Salsa20 的塊大小固定為 64 字節(jié)。

四、pycryptodome之Crypto.Hash

提供了哈希函數(shù)的實現(xiàn)。可以使用其中的類來計算消息的哈希值，支持常見的哈希算法，如MD5、SHA-1、SHA-256等。
1.Crypto.Hash.MD2：MD2哈希算法

• MD2.Buffer：表示 MD2 哈希函數(shù)的緩沖區(qū)大小。
• MD2.block_size：表示 MD2 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• MD2.digest_size：表示 MD2 哈希函數(shù)的輸出摘要的字節(jié)大小。
• MD2.new(data=None)：用于創(chuàng)建一個新的 MD2 哈希對象

from Crypto.Hash import MD2

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

md2 = MD2.new(data)

print('十六進制哈希值：',md2.hexdigest())
print('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• MD4.block_size：表示 MD4 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• MD4.digest_size：表示 MD4 哈希函數(shù)的輸出摘要的字節(jié)大小。
• MD4.new(data=None)：用于創(chuàng)建一個新的 MD4 哈希對象

from Crypto.Hash import MD4

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

md4 = MD4.new(data)

print('十六進制哈希值：',md4.hexdigest())
print('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• MD5.block_size：表示 MD5 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• MD5.digest_size：表示 MD5 哈希函數(shù)的輸出摘要的字節(jié)大小。
• MD5.new(data=None)：用于創(chuàng)建一個新的 MD5 哈希對象

from Crypto.Hash import MD5

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

md5 = MD5.new(data)

print('十六進制哈希值：',md5.hexdigest())
print('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• SHA256.block_size：表示 SHA256 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• SHA256.digest_size：表示 SHA256 哈希函數(shù)的輸出摘要的字節(jié)大小。
• SHA256.new(data=None)：用于創(chuàng)建一個新的 SHA256 哈希對象

from Crypto.Hash import SHA256

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

sha256 = SHA256.new(data)

print('十六進制哈希值：',sha256.hexdigest())
print('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• SHA1.block_size：表示 SHA1 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• SHA1.digest_size：表示 SHA1 哈希函數(shù)的輸出摘要的字節(jié)大小。
• SHA1.new(data=None)：用于創(chuàng)建一個新的 SHA1 哈希對象

from Crypto.Hash import SHA1

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

sha1 = SHA1.new(data)

print('十六進制哈希值：',sha1.hexdigest())
print('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• SHA224.block_size：表示 SHA224 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• SHA224.digest_size：表示 SHA224 哈希函數(shù)的輸出摘要的字節(jié)大小。
• SHA224.new(data=None)：用于創(chuàng)建一個新的 SHA224 哈希對象

from Crypto.Hash import SHA224

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

sha224 = SHA224.new(data)

print('十六進制哈希值：',sha224.hexdigest())
print('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• SHA384.block_size：表示 SHA384 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• SHA384.digest_size：表示 SHA384 哈希函數(shù)的輸出摘要的字節(jié)大小。
• SHA384.new(data=None)：用于創(chuàng)建一個新的 SHA384 哈希對象

from Crypto.Hash import SHA384

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

sha384 = SHA384.new(data)

print('十六進制哈希值：',sha384.hexdigest())
print('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• SHA512.block_size：表示 SHA512 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• SHA512.digest_size：表示 SHA512 哈希函數(shù)的輸出摘要的字節(jié)大小。
• SHA512.new(data=None)：用于創(chuàng)建一個新的 SHA512 哈希對象

from Crypto.Hash import SHA512

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

sha512 = SHA512.new(data)

print('十六進制哈希值：',sha512.hexdigest())
print('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• SHA3_224.block_size：表示 SHA3_224 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• SHA3_224.digest_size：表示 SHA3_224 哈希函數(shù)的輸出摘要的字節(jié)大小。
• SHA3_224.new(data=None,update_after_digest)：用于創(chuàng)建一個新的 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('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• SHA3_256.block_size：表示 SHA3_256 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• SHA3_256.digest_size：表示 SHA3_256 哈希函數(shù)的輸出摘要的字節(jié)大小。
• SHA3_256.new(data=None,update_after_digest)：用于創(chuàng)建一個新的 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('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• SHA3_384.block_size：表示 SHA3_384 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• SHA3_384.digest_size：表示 SHA3_384 哈希函數(shù)的輸出摘要的字節(jié)大小。
• SHA3_384.new(data=None,update_after_digest)：用于創(chuàng)建一個新的 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('十六字節(jié)哈希值：',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 哈希函數(shù)的緩沖區(qū)大小。
• SHA3_512.block_size：表示 SHA3_512 哈希函數(shù)的輸入塊大小，即每次處理的數(shù)據(jù)塊大小。
• SHA3_512.digest_size：表示 SHA3_512 哈希函數(shù)的輸出摘要的字節(jié)大小。
• SHA3_512.new(data=None,update_after_digest)：用于創(chuàng)建一個新的 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('十六字節(jié)哈希值：',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 衍生的可變長度哈希函數(shù)，可以生成不同長度的哈希值

• SHAKE128.Buffer：SHAKE128 哈希函數(shù)的緩沖區(qū)大小。
• SHAKE128.new(data)：創(chuàng)建一個新的 SHAKE128 哈希對象。

from Crypto.Hash import SHAKE128

data = b'hello word'

shake128 = SHAKE128.new(data)

shake128.update(b'hello')

print('字節(jié)哈希值：', shake128.read(10))

• Crypto.Hash.SHAKE256：SHAKE256哈希算法，SHA-3 衍生的可變長度哈希函數(shù)，可以生成不同長度的哈希值

• SHAKE256.Buffer：SHAKE256 哈希函數(shù)的緩沖區(qū)大小。
• SHAKE256.new(data)：創(chuàng)建一個新的 SHAKE256 哈希對象。

from Crypto.Hash import SHAKE256

data = b'hello word'

shake256 = SHAKE256.new(data)

shake256.update(b'hello')

print('字節(jié)哈希值：', shake256.read(10))

• Crypto.Hash.HMAC：這是基于哈希函數(shù)的密鑰相關的消息認證碼算法。它可以使用不同的哈希算法（如 SHA256、SHA512 等）來計算消息認證碼。

• HMAC.Buffer：表示 HMAC 哈希函數(shù)的緩沖區(qū)大小。
• HMAC.digest_size：表示 HMAC 哈希函數(shù)輸出的摘要（哈希值）的大小，以字節(jié)為單位。
• HMAC.new(key, msg, digestmod)：創(chuàng)建一個新的 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('十六字節(jié)哈希值：',hmac.digest())
print('哈希算法的哈希值大?。?,hmac.digest_size)
print('拷貝當前哈希對象：',hmac.copy())
print('驗證十六字節(jié)哈希值：',hmac.verify(hmac.digest()))
print('驗證十六進制哈希值：',hmac.hexverify(hmac.hexdigest()))

• Crypto.Hash.CMAC：這是一種基于對稱加密算法的消息認證碼算法。它使用一個密鑰和一個塊加密算法（如 AES）來計算消息認證碼。

• CMAC.Buffer：是一個常量，表示 CMAC 算法的緩沖區(qū)大小。
• CMAC.digest_size：表示 CMAC 算法輸出的摘要（MAC 值）的大小，以字節(jié)為單位。
• CMAC.new(key, msg, ciphermod, cipher_params, mac_len, update_after_digest)：用于創(chuàng)建一個新的 CMAC 算法對象

'''
key：表示用于計算 CMAC 的密鑰，是一個字節(jié)串。
msg：表示要計算 CMAC 的消息，也是一個字節(jié)串。
ciphermod：表示底層使用的對稱加密算法模塊，例如 Crypto.Cipher.AES、Crypto.Cipher.DES 等。
cipher_params：表示底層對稱加密算法的參數(shù)，例如 AES 加密算法的參數(shù)可以是一個字節(jié)串表示的密鑰。
mac_len：表示期望的 MAC 長度，以字節(jié)為單位。如果不指定，默認為底層對稱加密算法的塊大小。
update_after_digest：布爾值，表示在計算完摘要后是否允許繼續(xù)更新 CMAC 對象。如果為 True，可以繼續(xù)調用 update() 方法更新 CMAC 對象；如果為 False，在計算完摘要后調用 update() 方法將引發(fā)異常。默認為 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!"  # 要加密的數(shù)據(jù)


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

print('十六進制哈希值：', cmac.hexdigest())
print('十六字節(jié)哈希值：', cmac.digest())
print('哈希算法的哈希值大?。?, cmac.digest_size)
print('拷貝當前哈希對象：', cmac.copy())
print('驗證十六字節(jié)哈希值：', 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 哈希值的字節(jié)大小。
• RIPEMD160.block_size：RIPEMD-160 算法的分塊大小。
• RIPEMD160.Buffer：RIPEMD-160 哈希值的緩沖區(qū)。
• RIPEMD160.new(data=None)：創(chuàng)建一個新的 RIPEMD160 哈希對象

from Crypto.Hash import RIPEMD160

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

ripemd160 = RIPEMD160.new(data)

print('十六進制哈希值：', ripemd160.hexdigest())
print('十六字節(jié)哈希值：', 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 哈希值的緩沖區(qū)。
• KMAC128.new(key, data=None, mac_len=None, custom=None)：創(chuàng)建一個新的 KMAC128 哈希對象

'''
key：密鑰。它是一個字節(jié)串（bytes），用于計算哈希值和認證標簽。
data：要計算哈希值的數(shù)據(jù)。它是一個字節(jié)串（bytes）。
mac_len：期望的哈希值的長度（以比特為單位）。如果未指定，將使用默認的哈希值長度。
custom：自定義字符串，用于與密鑰一起計算哈希值和認證標簽。它是一個字節(jié)串（bytes）
'''
from Crypto.Hash import KMAC128
from Crypto.Random import get_random_bytes

key = get_random_bytes(16)  # 密鑰
data = b"Hello, world!"  # 要計算哈希值的數(shù)據(jù)
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('十六字節(jié)哈希值：', kmac128.digest())
print('驗證十六字節(jié)哈希值：', kmac128.verify(kmac128.digest()))
print('驗證十六進制哈希值：', kmac128.hexverify(kmac128.hexdigest()))

• Crypto.Hash.KMAC256：這些是基于 Keccak 算法的可變長度哈希函數(shù)，可以生成不同長度的哈希值。

• KMAC256.Buffer：KMAC128 哈希值的緩沖區(qū)。
• KMAC256.new(key, data=None, mac_len=None, custom=None)：創(chuàng)建一個新的 KMAC256 哈希對象

'''
key：密鑰。它是一個字節(jié)串（bytes），用于計算哈希值和認證標簽。
data：要計算哈希值的數(shù)據(jù)。它是一個字節(jié)串（bytes）。
mac_len：期望的哈希值的長度（以比特為單位）。如果未指定，將使用默認的哈希值長度。
custom：自定義字符串，用于與密鑰一起計算哈希值和認證標簽。它是一個字節(jié)串（bytes）
'''
from Crypto.Hash import KMAC256
from Crypto.Random import get_random_bytes

key = get_random_bytes(32)  # 密鑰
data = b"Hello, world!"  # 要計算哈希值的數(shù)據(jù)
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('十六字節(jié)哈希值：', kmac256.digest())
print('驗證十六字節(jié)哈希值：', kmac256.verify(kmac256.digest()))
print('驗證十六進制哈希值：', kmac256.hexverify(kmac256.hexdigest()))

• Crypto.Hash.TupleHash128：基于 Keccak 算法的元組哈希函數(shù)，用于將多個輸入值組合成單個哈希值

• TupleHash128.Buffer：TupleHash128 哈希值的緩沖區(qū)。
• TupleHash128.new(digest_bytes,digest_bits,custom)：創(chuàng)建一個新的 TupleHash128 哈希對象

'''
digest_bytes：必要計算哈希值的數(shù)據(jù)。它是一個字節(jié)串（bytes）。
digest_bits：期望的哈希值的長度（以比特為單位）。
custom：自定義字符串，用于計算哈希值。它是一個字節(jié)串（bytes）
'''
from Crypto.Hash import TupleHash128


custom = b"Hello, world!"  # 消息數(shù)據(jù)


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

tulphash128.update(b'hello')

print('十六進制哈希值：', tulphash128.hexdigest())
print('十六字節(jié)哈希值：', tulphash128.digest())

• Crypto.Hash.TupleHash256：這些是基于 Keccak 算法的元組哈希函數(shù)，用于將多個輸入值組合成單個哈希值。

• TupleHash256.Buffer：TupleHash256 哈希值的緩沖區(qū)。
• TupleHash256.new(digest_bytes,digest_bits,custom)：創(chuàng)建一個新的 TupleHash256 哈希對象

'''
digest_bytes：必要計算哈希值的數(shù)據(jù)。它是一個字節(jié)串（bytes）。
digest_bits：期望的哈希值的長度（以比特為單位）。
custom：自定義字符串，用于計算哈希值。它是一個字節(jié)串（bytes）
'''
from Crypto.Hash import TupleHash256


custom = b"Hello, world!"  # 消息數(shù)據(jù)


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

tulphash256.update(b'hello')

print('十六進制哈希值：', tulphash256.hexdigest())
print('十六字節(jié)哈希值：', tulphash256.digest())

• Crypto.Hash.BLAKE2s：BLAKE2 系列的哈希函數(shù)，提供高速和安全的哈希計算

• BLAKE2s.Buffer：BLAKE2s 哈希值的緩沖區(qū)。
• BLAKE2s.new(data,digest_bytesdigest_bitskey,update_after_digest)：創(chuàng)建一個新的 BLAKE2s 哈希對象

'''
data：要計算哈希值的數(shù)據(jù)。它是一個字節(jié)串（bytes）。
digest_bytes：期望的哈希值的長度（以字節(jié)為單位），默認的哈希值長度（32 字節(jié)），與digest_bits參數(shù)沖突
digest_bits：期望的哈希值的長度（以比特為單位），默認的哈希值長度（256 比特），與digest_bytes參數(shù)沖突
key：用于計算哈希值的密鑰。它是一個字節(jié)串（bytes）。如果未提供該參數(shù)，則不使用密鑰進行計算。
update_after_digest：在計算哈希值后是否允許繼續(xù)更新數(shù)據(jù)。如果設置為 True，則可以在計算哈希值后繼續(xù)使用 update() 方法添加更多數(shù)據(jù)
'''
from Crypto.Hash import BLAKE2s
from Crypto.Random import get_random_bytes


key = get_random_bytes(32)  # 密鑰
data = b"Hello, world!"  # 要計算哈希值的數(shù)據(jù)
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('十六字節(jié)哈希值：', blake2s.digest())
print('驗證十六字節(jié)哈希值：', blake2s.verify(blake2s.digest()))
print('驗證十六進制哈希值：', blake2s.hexverify(blake2s.hexdigest()))

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

• Crypto.Hash.BLAKE2b：BLAKE2 系列的哈希函數(shù)，提供高速和安全的哈希計算

• BLAKE2b.Buffer：BLAKE2b 哈希值的緩沖區(qū)。
• BLAKE2b.new(data,digest_bytesdigest_bitskey,update_after_digest)：創(chuàng)建一個新的BLAKE2b 哈希對象

'''
data：要計算哈希值的數(shù)據(jù)。它是一個字節(jié)串（bytes）。
digest_bytes：期望的哈希值的長度（以字節(jié)為單位），默認的哈希值長度（32 字節(jié)），與digest_bits參數(shù)沖突
digest_bits：期望的哈希值的長度（以比特為單位），默認的哈希值長度（256 比特），與digest_bytes參數(shù)沖突
key：用于計算哈希值的密鑰。它是一個字節(jié)串（bytes）。如果未提供該參數(shù)，則不使用密鑰進行計算。
update_after_digest：在計算哈希值后是否允許繼續(xù)更新數(shù)據(jù)。如果設置為 True，則可以在計算哈希值后繼續(xù)使用 update() 方法添加更多數(shù)據(jù)
'''
from Crypto.Hash import BLAKE2b
from Crypto.Random import get_random_bytes


key = get_random_bytes(32)  # 密鑰
data = b"Hello, world!"  # 要計算哈希值的數(shù)據(jù)
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('十六字節(jié)哈希值：', blake2b.digest())
print('驗證十六字節(jié)哈希值：', blake2b.verify(blake2b.digest()))
print('驗證十六進制哈希值：', blake2b.hexverify(blake2b.hexdigest()))

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

• Crypto.Hash.KangarooTwelve：這是一種快速的哈希函數(shù)，適用于各種應用場景。

• KangarooTwelve.Buffer：KangarooTwelve 哈希值的緩沖區(qū)。

'''
data：要計算哈希值的數(shù)據(jù)。它可以是字節(jié)串（bytes）、字節(jié)數(shù)組（bytearray）或可迭代對象，例如字符串。如果是可迭代對象，它將在計算哈希值之前被轉換為字節(jié)串。
custom：可選的自定義字符串。它是一個字節(jié)串（bytes），用于在計算哈希值時添加自定義的上下文信息。如果不提供 custom 參數(shù)，則默認為 None
'''
from Crypto.Hash import KangarooTwelve


data = b"Hello, world!"  # 消息數(shù)據(jù)
custom = b"Hello, world!"  # 消息數(shù)據(jù)


kangarootwelve = KangarooTwelve.new(data,custom)

# kangarootwelve.update(b"hello")

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

• Crypto.Hash.Poly1305：這是一種消息認證碼算法，用于計算消息的認證標簽。

• Poly1305.Buffer：Poly1305 哈希值的緩沖區(qū)。
• Poly1305.new(key, cipher, nonce, data)：創(chuàng)建一個新的Poly1305 哈希對象

'''
key：用于計算認證標簽的密鑰。它是一個字節(jié)串（bytes），長度為 32 字節(jié)。Poly1305 算法要求密鑰長度為 256 比特。
cipher：用于加密消息的加密算法。它是一個可調用的加密函數(shù)，接受兩個參數(shù)：密鑰和 nonce。該函數(shù)將返回一個加密器對象，用于加密數(shù)據(jù)。
nonce：用于加密消息的一次性值。它是一個字節(jié)串（bytes），長度為 16 字節(jié)。每個消息都應該使用不同的 nonce 值，以確保安全性。
data：要計算認證標簽的消息數(shù)據(jù)。它是一個字節(jié)串（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!"  # 消息數(shù)據(jù)

cipher = ChaCha20.new(key=key, nonce=nonce)  # 創(chuàng)建 ChaCha20 加密器
encrypted_data = cipher.encrypt(data)  # 加密消息數(shù)據(jù)

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

# POLY1305.update(b"hello")

print('十六進制哈希值：', POLY1305.hexdigest())
print('十六字節(jié)哈希值：', POLY1305.digest())
print('驗證十六字節(jié)哈希值：', POLY1305.verify(POLY1305.digest()))
print('驗證十六進制哈希值：', POLY1305.hexverify(POLY1305.hexdigest()))

五、pycryptodome之Crypto.IO

提供了一些輸入輸出相關的功能。例如，可以使用其中的類來進行文件的加密和解密操作。

• Crypto.IO.PEM：處理 PEM（Privacy-Enhanced Mail）格式的數(shù)據(jù)。PEM 是一種常見的用于存儲和傳輸加密數(shù)據(jù)的格式，如證書、私鑰等。PEM 模塊可以用于讀取、寫入和解析 PEM 格式的數(shù)據(jù)

• PEM.encode(data,marke,passphrase,randfunc)：編碼為 PEM 數(shù)據(jù)

data：要編碼為 PEM 格式的二進制數(shù)據(jù)。可以是字節(jié)串或可迭代對象，如字符串或字節(jié)數(shù)組。
marker：可選參數(shù)，表示 PEM 數(shù)據(jù)塊的標記（marker）。默認值為 None，表示沒有標記。如果提供了標記，將在 PEM 數(shù)據(jù)塊的起始行和結束行之間添加標記。
passphrase：可選參數(shù)，用于加密 PEM 數(shù)據(jù)塊的密碼短語（passphrase）。默認值為 None，表示不加密。如果提供了密碼短語，將使用它對 PEM 數(shù)據(jù)塊進行加密。
randfunc：可選參數(shù)，用于生成隨機數(shù)據(jù)的隨機數(shù)生成器函數(shù)。默認值為 None，表示使用默認的隨機數(shù)生成器。如果需要加密 PEM 數(shù)據(jù)塊，則需要提供一個隨機數(shù)生成器函數(shù)。 

• PEM.decode(pem_data, passphrase)：解碼 PEM 數(shù)據(jù)

'''
pem_data：要解碼的 PEM 格式數(shù)據(jù)，可以是字節(jié)串或字符串。它應該包含完整的 PEM 數(shù)據(jù)塊，包括起始行（如 "-----BEGIN XYZ-----"）和結束行（如 "-----END XYZ-----"）。
passphrase：可選參數(shù)，用于解密加密的 PEM 數(shù)據(jù)塊的密碼短語（passphrase）。如果 PEM 數(shù)據(jù)塊未加密，則可以將此參數(shù)設置為 None 或省略。
'''
from Crypto.IO import PEM

data = b'Hello, world!'  # 待編碼的數(shù)據(jù)

pem_data = PEM.encode(data, 'DATA')  # 編碼為 PEM 格式

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

print('原數(shù)據(jù)：', data)
print('編碼后的數(shù)據(jù)：', pem_data)
print('解碼后的數(shù)據(jù)：', decoded_data)

• Crypto.IO.PKCS8：處理 PKCS8格式的數(shù)據(jù)。PKCS8是一種標準的格式，用于存儲和傳輸公鑰和私鑰。PKCS8 模塊可以用于讀取、寫入和解析 PKCS8格式的數(shù)據(jù)。

• 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）。可以是字符串或字節(jié)串。
protection: 加密算法的標識符，用于保護私鑰數(shù)據(jù)。可以是字符串或字節(jié)串。常見的值包括 "PBKDF2WithHMAC-SHA256AndAES256-CBC" 和 "PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC"。
prot_params: 保護參數(shù)，用于指定加密算法的參數(shù)?？梢允亲值浠?None。
key_params: 私鑰參數(shù)，用于指定私鑰的格式和編碼方式。可以是字典或 None。
randfunc: 用于生成隨機數(shù)據(jù)的隨機數(shù)生成器函數(shù)。默認值為 None，表示使用默認的隨機數(shù)生成器。 

• PKCS8.unwrap(p8_private_key, passphrase)：解密包含有加密私鑰信息的 PKCS8 格式數(shù)據(jù)

'''
p8_private_key: 包含加密私鑰信息的 PKCS#8 格式數(shù)據(jù)。可以是字節(jié)串或字符串。
passphrase: 解密私鑰的密碼短語（passphrase）?？梢允亲址蜃止?jié)串。
'''

六、pycryptodome之Crypto.Signature

提供了數(shù)字簽名算法的實現(xiàn)。可以使用其中的類來進行數(shù)字簽名和驗證，支持常見的數(shù)字簽名算法

• Crypto.Signature.PKCS1_v1_5：PKCS1_v1_5 是一種經(jīng)典的 RSA 簽名方案，使用 RSA 密鑰對進行簽名和驗證。該方案在許多應用中廣泛使用。

'''
rsa_key：RSA 密鑰對象。它可以是一個 Crypto.PublicKey.RSA 對象，表示一個 RSA 密鑰對?？梢允褂?RSA.generate() 方法來生成密鑰對，或者使用 Crypto.PublicKey.RSA.import_key() 方法從已有的密鑰數(shù)據(jù)中導入密鑰對
'''
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!'  # 加密數(shù)據(jù)signer = PKCS1_v1_5.new(key) # 創(chuàng)建 PKCS1_v1_5 驗證對象# 數(shù)據(jù)data = b"Hello, world!"# 使用私鑰進行簽名hash_value = MD5.new(data)
signature = signer.sign(hash_value)

verifier = PKCS1_v1_5.new(key) # 創(chuàng)建 PKCS1_v1_5 驗證對象print("驗證密鑰RSA密鑰是否適用PKCS1_v1_5簽名:", verifier.can_sign())
print("簽名驗證結果:", verifier.verify(hash_value, signature))

• Crypto.Signature.PKCS1_PSS：使用 RSA 密鑰對進行簽名和驗證，PKCS1_PSS 是一種更現(xiàn)代的 RSA 簽名方案，提供更好的安全性和抗攻擊性能。

'''
rsa_key：RSA 密鑰對象。它可以是一個 Crypto.PublicKey.RSA 對象，表示一個 RSA 密鑰對。可以使用 RSA.generate() 方法來生成密鑰對，或者使用 Crypto.PublicKey.RSA.import_key() 方法從已有的密鑰數(shù)據(jù)中導入密鑰對。
mgfunc：消息生成函數(shù)。它是一個可選參數(shù)，用于指定一個哈希算法，用于生成消息的掩碼。默認值為 Crypto.Hash.MGF1。
saltLen：鹽的長度。它是一個可選參數(shù)，用于指定鹽的長度（以字節(jié)為單位）。默認值為 Crypto.Signature.PKCS1_PSS.MAX_LENGTH，表示使用與密鑰長度相同的鹽長度。
randfunc：隨機數(shù)生成函數(shù)。它是一個可選參數(shù)，用于生成隨機數(shù)。默認值為 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!'  # 加密數(shù)據(jù)

signer = PKCS1_PSS.new(key) # 創(chuàng)建PKCS1_PSS驗證對象

# 數(shù)據(jù)
data = b"Hello, world!"

# 使用私鑰進行簽名
hash_value = MD5.new(data)
signature = signer.sign(hash_value)

verifier = PKCS1_PSS.new(key) # 創(chuàng)建PKCS1_PSS驗證對象

print("驗證密鑰RSA密鑰是否適用PKCS1_PSS簽名:", verifier.can_sign())
print("簽名驗證結果:", verifier.verify(hash_value, signature))

• Crypto.Signature.DSS：使用 DSA 密鑰對進行簽名和驗證，適用于需要較短簽名長度和高性能的場景，DSA 是一種非對稱加密算法，用于數(shù)字簽名

'''
key：DSA 密鑰對象，可以使用 Crypto.PublicKey.DSA 類生成密鑰對，并將私鑰或公鑰對象傳遞給構造函數(shù)。
mode：字符串，指定 DSS 簽名模式?？梢允褂?'fips-186-3' 或 'deterministic-rfc6979'。
encoding：字符串，指定消息的編碼方式。可以使用 'raw' 或 'der'。
randfunc：可選參數(shù)，用于生成隨機數(shù)的函數(shù)。如果不提供此參數(shù)，則使用默認的隨機數(shù)生成函數(shù)。
'''
from Crypto.PublicKey import DSA
from Crypto.Signature import DSS
from Crypto.Hash import SHA256

key = DSA.generate(2048)  # 生成 DSA 密鑰對
plaintext = b'Hello, world!'  # 加密數(shù)據(jù)
mode = 'fips-186-3'

signer = DSS.new(key, mode)  # 創(chuàng)建 DSS 簽名對象

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

verifier = DSS.new(key, mode)  # 創(chuàng)建 DSS 驗證對象

print("驗證密鑰 DSA 密鑰是否適用 DSS 簽名:", verifier.can_sign())
print("簽名驗證結果:", verifier.verify(hash_value, signature))

七、pycryptodome之Crypto.PublicKey

提供了非對稱加密算法（公鑰加密算法）的實現(xiàn)?？梢允褂闷渲械念悂砩擅荑€對、進行加密和解密操作，支持常見的非對稱加密算法，如RSA、DSA等。

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

• RSA.RsaKey：RsaKey 是一個類，表示 RSA 密鑰對。它是 RSA 密鑰對的基類，包括公鑰和私鑰。

RSA.RsaKey.e：公鑰指數(shù)。在 RSA 密鑰對中，公鑰由指數(shù) e 和模數(shù) n 組成。
RSA.RsaKey.n：模數(shù)。在 RSA 密鑰對中，模數(shù) n 是一個大整數(shù)，用于加密和解密操作。
RSA.RsaKey.d：私鑰指數(shù)。在 RSA 密鑰對中，私鑰由指數(shù) d 和模數(shù) n 組成。
RSA.RsaKey.invp：p 的模反元素。在 RSA 密鑰對中，p 是模數(shù) n 的一個素因子。
RSA.RsaKey.invq：q 的模反元素。在 RSA 密鑰對中，q 是模數(shù) 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()：返回密鑰的位數(shù)。
RSA.RsaKey.size_in_bytes()：返回密鑰的字節(jié)數(shù)。 

• RSA.construct(rsa_components)：用于根據(jù)給定的 RSA 組件構造 RSA 密鑰對，返回RsaKey對象

rsa_components 是一個字典，包含了 RSA 密鑰的組件，如 n（模數(shù)）、e（公鑰指數(shù)）、d（私鑰指數(shù)）等。 

• RSA.generate(bits, randfunc, e=65537)：用于生成指定位數(shù)的 RSA 密鑰對，返回RsaKey對象

bits 是密鑰的位數(shù)
randfunc 是一個隨機數(shù)生成函數(shù)
e 是公鑰指數(shù)，默認為 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)：將密鑰導出為字符串。該方法可以接受多個參數(shù)，包括 format（導出格式，默認為 PEM）、pkcs8（是否使用 PKCS#8 格式，默認為 False）、passphrase（密鑰的密碼，可選）、protection（密鑰的保護級別，默認為 None）和 randfunc（隨機數(shù)生成函數(shù)，可選）。
DSA.DsaKey.has_private()：檢查密鑰是否包含私鑰。
DSA.DsaKey.can_sign()：檢查密鑰是否可用于簽名操作。
DSA.DsaKey.can_encrypt()：檢查密鑰是否可用于加密操作。
DSA.DsaKey.domain()：返回 DSA 密鑰對的域參數(shù)。該方法返回一個字典，包含了 DSA 密鑰對的參數(shù)，如 p（素數(shù)）、q（素數(shù)）、g（生成元）等。 

• DSA.generate(bits, randfunc, domain)：用于生成指定位數(shù)的 DSA 密鑰對，返回DsaKey對象

bits 是密鑰的位數(shù)
randfunc 是一個隨機數(shù)生成函數(shù)
domain 是一個字典，包含了 DSA 密鑰對的域參數(shù)，如 p（素數(shù)）、q（素數(shù)）、g（生成元）等。 

• DSA.import_key(extern_key, passphrase)：用于從外部密鑰（如 PEM 格式的密鑰文件）中導入 DSA 密鑰，返回DsaKey對象

extern_key 是一個表示外部密鑰的字符串或文件對象
passphrase 是密鑰的密碼（如果有的話）。 

• DSA.construct(tup, consistency_check)：construct 是一個函數(shù)，用于根據(jù)給定的元組構造 DSA 密鑰對，返回DsaKey對象

tup 是一個元組，包含了 DSA 密鑰的組件，如 y（公鑰）、x（私鑰）、p（素數(shù)）、q（素數(shù)）、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)：用于生成指定位數(shù)的 ElGamal 密鑰對

bits 是密鑰的位數(shù)
randfunc 是一個隨機數(shù)生成函數(shù)。 

• ElGamal.construct(tup)：用于根據(jù)給定的元組構造 ElGamal 密鑰對

tup 是一個元組，包含了 ElGamal 密鑰的組件，如 p（素數(shù)）、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 密鑰對的數(shù)據(jù)。format 參數(shù)指定導出的格式，默認為 'PEM' 格式。
ECC.EccKey.public_key()：用于獲取 ECC 密鑰對的公鑰部分。它返回一個新的 ECC.EccKey 對象，其中只包含公鑰信息，不包含私鑰信息。
ECC.EccKey.has_private()：用于檢查 ECC 密鑰對是否包含私鑰。如果密鑰對包含私鑰，則返回 True；否則，返回 False。 

• ECC.generate(**kwargs)：generate() 函數(shù)用于生成一個新的 ECC 密鑰對?？梢酝ㄟ^關鍵字參數(shù)來指定生成密鑰對的方式和參數(shù)，返回EccKey對象

curve：指定要使用的橢圓曲線，可以是一個 ECC.Curve 對象或橢圓曲線的名稱。
entropy：指定用于生成密鑰對的熵（隨機性），可以是一個字節(jié)串或一個可調用對象。
randfunc：指定用于生成隨機數(shù)的函數(shù)。默認情況下，使用系統(tǒng)提供的隨機數(shù)生成函數(shù)。 

• ECC.construct(**kwargs)：construct() 函數(shù)用于根據(jù)給定的參數(shù)構造一個 ECC 密鑰對，返回EccKey對象

curve：指定要使用的橢圓曲線，可以是一個 ECC.Curve 對象或橢圓曲線的名稱。
point：指定曲線上的一個點，可以是一個 ECC.Point 對象或表示點坐標的元組。 

• ECC.import_key(encoded, passphrase=None, curve_name=None)：import_key() 函數(shù)用于從給定的數(shù)據(jù)導入一個 ECC 密鑰對，返回EccKey對象

encoded：表示要導入的密鑰對的數(shù)據(jù)，可以是一個字節(jié)串或字符串。
passphrase（可選）：如果密鑰對被密碼保護，需要提供正確的密碼短語才能成功導入密鑰對。
curve_name（可選）：指定要使用的橢圓曲線的名稱。

八、pycryptodome之Crypto.Random

提供了生成隨機數(shù)的功能。可以使用其中的函數(shù)來生成偽隨機數(shù)和強隨機數(shù)。

• Crypto.Random.random：隨機數(shù)

• random.choice(seq)：從給定的序列中隨機選擇一個元素并返回。

'''
sep：這可迭代的序列，例如列表、元組或字符串，然后從中隨機選擇一個元素并返回
'''

• random.sample(population, k)：從給定的總體中隨機選擇指定數(shù)量的唯一元素，并以列表形式返回。

'''
population：可迭代的總體作為參數(shù)，例如列表、元組或字符串，然后從中隨機選擇指定數(shù)量的唯一元素，并以列表形式返回。
k：指定返回數(shù)量
'''

• random.randint(a, b)：生成一個指定范圍內的隨機整數(shù)，范圍包括a和b
• random.getrandbits(k)：生成一個k位的隨機整數(shù)，并返回
• random.randrange(start, stop[, step])：從指定范圍內按指定步長隨機選擇一個整數(shù)并返回

'''
start表示起始值（包含）
stop表示終止值（不包含）
step表示步長，默認為1
'''

• andom.shuffle(x)：隨機打亂可變序列（例如列表），直接修改原始序列直接修改原始序列

• Crypto.Random.get_random_bytes(n)：生成一個包含n個隨機字節(jié)的字節(jié)串
• Crypto.Random.getrandbits(k)：生成一個k位的隨機整數(shù)==
• Crypto.Random.atfork()：在多線程環(huán)境中使用，用于重置隨機數(shù)生成器的狀態(tài)。這個函數(shù)會在fork子進程之前調用，以避免子進程繼承父進程的隨機數(shù)狀態(tài)。

九、pycryptodome之Crypto.Util

提供了一些常用的工具函數(shù)。例如，可以使用其中的函數(shù)來進行字節(jié)串的編碼、解碼，進行填充操作等。

• Crypto.Util.Padding：提供了填充和去填充數(shù)據(jù)的函數(shù)。

• pad(data_to_pad, block_sizet style)：用于填充數(shù)據(jù)

'''
data_to_pad：要進行填充的數(shù)據(jù)，類型為字節(jié)串（bytes）。
block_size：數(shù)據(jù)塊的長度，以字節(jié)為單位。填充后的數(shù)據(jù)長度將是 block_size 的整數(shù)倍。
style：填充的風格，可選值為 'pkcs7'、'iso7816'、'x923'、'iso10126'、'zero' 或 None。默認值為 'pkcs7'。

None：不進行填充，如果數(shù)據(jù)長度不是塊長度的整數(shù)倍，則會引發(fā) ValueError 異常。
'''

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

padded_data：已填充的數(shù)據(jù)，類型為字節(jié)串（bytes）。
block_size：數(shù)據(jù)塊的長度，以字節(jié)為單位。
style：填充的風格，與 pad() 函數(shù)中的風格參數(shù)相同。默認值為 'pkcs7'。

• Crypto.Util.number：提供了處理大整數(shù)的函數(shù)，例如生成隨機素數(shù)、計算模反元素等。

• number.inverse(x, m)：計算模 m 下 x 的乘法逆元。返回值為 x 在模 m 下的乘法逆元。
• number.size(x)：返回整數(shù) x 的字節(jié)大小。
• number.GCD(a, b)：計算整數(shù) a 和 b 的最大公約數(shù)（Greatest Common Divisor，GCD）。返回值為 a 和 b 的最大公約數(shù)。
• number.bytes_to_long(s)：將字節(jié)串 s 轉換為對應的長整數(shù)。
• number.long_to_bytes(n, blocksize)：將長整數(shù) n 轉換為字節(jié)串，其中 blocksize 指定了輸出的字節(jié)塊大小。
• number.ceil_div(a, b)：計算整數(shù) a 除以整數(shù) b 的向上取整除法結果。
• number.getPrime(N, randfunc=None)：生成一個 N 位的素數(shù)。可選參數(shù) randfunc 是一個隨機數(shù)生成函數(shù)，用于生成隨機數(shù)。
• number.getRandomInteger(N, randfunc=None)：生成一個 N 位的隨機整數(shù)?？蛇x參數(shù) randfunc 是一個隨機數(shù)生成函數(shù)，用于生成隨機數(shù)。
• number.getRandomNBitInteger(N, randfunc=None)：生成一個 N 位的隨機整數(shù)。可選參數(shù) randfunc 是一個隨機數(shù)生成函數(shù)，用于生成隨機數(shù)。
• number.getRandomRange(start, stop, randfunc=None)：生成一個在范圍 [start, stop) 內的隨機整數(shù)?？蛇x參數(shù) randfunc 是一個隨機數(shù)生成函數(shù)，用于生成隨機數(shù)。
• number.getStrongPrime(N, e, randfunc=None)：生成一個 N 位的強素數(shù)，其中 e 是公共指數(shù)?？蛇x參數(shù) randfunc 是一個隨機數(shù)生成函數(shù)，用于生成隨機數(shù)。
• number.isPrime(n, k=10)：檢查整數(shù) n 是否為素數(shù)?？蛇x參數(shù) k 指定了進行 Miller-Rabin 素性測試的次數(shù)。
• number.long2str(n)：將長整數(shù) n 轉換為字節(jié)串。
• number.str2long(s)：將字節(jié)串 s 轉換為長整數(shù)。

• Crypto.Util.py3compat：提供了與 Python 2 和 Python 3 兼容性相關的函數(shù)和類。

• py3compat.bord(x)：將字節(jié)或字符 x 轉換為對應的整數(shù)值。在 Python 2 中，x 可以是一個字符或字節(jié)；在 Python 3 中，x 必須是一個整數(shù)。
• py3compat.bchr(x)：將整數(shù) x 轉換為對應的字節(jié)或字符。在 Python 2 中，返回一個字符；在 Python 3 中，返回一個字節(jié)。
• py3compat.tobytes(x)：將輸入 x 轉換為字節(jié)串。在 Python 2 中，x 可以是一個字符串或字節(jié)串；在 Python 3 中，x 必須是一個字符串。
• py3compat.b(x)：將輸入 x 轉換為字節(jié)串。在 Python 2 中，返回輸入 x 本身；在 Python 3 中，如果 x 是字符串，則返回其對應的字節(jié)串。
• py3compat.BytesIO()：創(chuàng)建一個類似于文件對象的字節(jié)串緩沖區(qū)。在 Python 2 和 Python 3 中都可用。
• py3compat.bytestring(x)：將輸入 x 轉換為字節(jié)串。在 Python 2 中，x 可以是一個字符串或字節(jié)串；在 Python 3 中，x 必須是一個字符串。
• py3compat.is_bytes(x)：檢查輸入 x 是否為字節(jié)串。在 Python 2 和 Python 3 中都可用。
• py3compat.is_native_int(x)：檢查輸入 x 是否為本機整數(shù)類型。在 Python 2 和 Python 3 中都可用。
• py3compat.is_string(x)：檢查輸入 x 是否為字符串類型。在 Python 2 和 Python 3 中都可用。
• py3compat.StringIO()：創(chuàng)建一個類似于文件對象的字符串緩沖區(qū)。在 Python 2 和 Python 3 中都可用。
• py3compat.tostr(x)：將輸入 x 轉換為字符串。在 Python 2 中，x 可以是一個字符串或字節(jié)串；在 Python 3 中，x 必須是一個字符串。

十、pycryptodome之Crypto.Protocol

提供了一些密碼學協(xié)議的實現(xiàn)。例如，可以使用其中的類來進行密鑰交換、安全通信等。

• Crypto.Protocol.SecretSharing：秘密共享，通過將秘密分割成多個部分（份額），可以將其分發(fā)給不同的參與者。只有在達到指定的閾值份額時，才能恢復原始的秘密。這對于實現(xiàn)安全的多方協(xié)議和數(shù)據(jù)保護非常有用。

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

k：一個整數(shù)，表示恢復秘密所需的最小份額數(shù)。
n：一個整數(shù)，表示生成的總份額數(shù)。
secret：一個字節(jié)串，表示要分割的原始秘密，16字節(jié)。
ssss：一個整數(shù)，表示生成份額時使用的隨機數(shù)種子 

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

'''
shares：一個包含份額的列表。
ssss：一個整數(shù)，表示生成份額時使用的隨機數(shù)種子。
'''
from Crypto.Protocol.SecretSharing import Shamir

k = 3  # 恢復秘密所需的最小份額數(shù)
n = 5  # 生成的總份額數(shù)
secret = b"Hello,Word!!!!!!"  # 要分割的原始秘密

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

recovered_secret = Shamir.combine(shares[:k]) # 組合份額恢復秘密
print("恢復的秘密：", recovered_secret)

• Crypto.Protocol.KDF：密鑰派生，密鑰派生函數(shù)可以從一個輸入密鑰派生出更長或更復雜的密鑰，以供加密、認證或其他密碼學操作使用。

• KDF.HKDF(master, key_len, salts, hashmod, num_keys, context)：基于 HMAC 的密鑰派生函數(shù)（HKDF）的實現(xiàn)。它使用輸入的主密鑰（master）和其他可選參數(shù)來派生一個或多個密鑰，返回一個包含派生密鑰的列表。

master：一個字節(jié)串，作為主密鑰。
key_len：一個整數(shù)，表示派生密鑰的長度。
salts：一個字節(jié)串或一個列表，用于指定鹽值。如果提供了多個鹽值，則會使用每個鹽值進行密鑰派生，并將結果連接在一起。
hashmod：一個哈希模塊，例如 Crypto.Hash.SHA256。
num_keys：一個整數(shù)，表示要派生的密鑰個數(shù)。
context：一個字節(jié)串，用于提供上下文信息。 

• KDF.scrypt(password, salt, key_len, N, r, p, num_keys)：基于密碼派生函數(shù)的實現(xiàn)。它使用密碼和鹽值作為輸入，并使用一組參數(shù)來派生一個或多個密鑰，返回一個包含派生密鑰的列表。

password：一個字節(jié)串，作為密碼。
salt：一個字節(jié)串，作為鹽值。
key_len：一個整數(shù)，表示派生密鑰的長度。
N：一個整數(shù)，表示 scrypt 的 CPU/內存成本因子。
r：一個整數(shù)，表示 scrypt 的塊大小。
p：一個整數(shù)，表示 scrypt 的并行化因子。
num_keys：一個整數(shù)，表示要派生的密鑰個數(shù)。 

• KDF.bcrypt(password, cost, salt)：bcrypt 密碼哈希函數(shù)的實現(xiàn)。它使用密碼和鹽值作為輸入，并使用指定的計算成本（cost）來計算哈希值，返回一個包含 bcrypt 哈希值的字節(jié)串

password：一個字節(jié)串，作為密碼。
cost：一個整數(shù)，表示計算成本，即計算哈希值所需的時間和資源。
salt：一個字節(jié)串，作為鹽值。 

• KDF.bcrypt_check(password, bcrypt_hash)：驗證 bcrypt 哈希值的函數(shù)。它使用密碼和存儲的 bcrypt 哈希值作為輸入，并返回一個布爾值，指示密碼是否匹配存儲的哈希值，返回一個布爾值，指示密碼是否匹配存儲的哈希值。

password：一個字節(jié)串，作為密碼。
bcrypt_hash：一個字節(jié)串，作為存儲的 bcrypt 哈希值。 

• KDF.PBKDF1(password, salt, dkLen, count, hashAlgo)：PBKDF1 密碼基于密碼派生函數(shù)的實現(xiàn)。它使用密碼和鹽值作為輸入，并使用指定的哈希算法和迭代次數(shù)來派生密鑰，返回一個包含派生密鑰的字節(jié)串。

password：一個字節(jié)串，作為密碼。
salt：一個字節(jié)串，作為鹽值。
dkLen：一個整數(shù)，表示派生密鑰的長度。
count：一個整數(shù)，表示迭代次數(shù)。
hashAlgo：一個哈希算法模塊，例如 Crypto.Hash.SHA256。 

• KDF.PBKDF2(password, salt, dkLen, count, prf, hmac_hash_module)：BKDF2 密碼基于密碼派生函數(shù)的實現(xiàn)。它使用密碼和鹽值作為輸入，并使用指定的偽隨機函數(shù)（PRF）和迭代次數(shù)來派生密鑰，返回一個包含派生密鑰的字節(jié)串。

password：一個字節(jié)串，作為密碼。
salt：一個字節(jié)串，作為鹽值。
dkLen：一個整數(shù)，表示派生密鑰的長度。
count：一個整數(shù)，表示迭代次數(shù)。
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 密鑰派生函數(shù)派生密鑰
  master：主密鑰。

master：主密鑰。
key_len：派生密鑰的長度（以字節(jié)為單位）。
prf：偽隨機函數(shù)。
num_keys：要派生的密鑰數(shù)量。
label：標簽。
context：上下文數(shù)據(jù)（可選參數(shù)）。

十一、pycryptodome之Crypto.Math

提供了一些密碼學相關的數(shù)學函數(shù)和算法的實現(xiàn)。例如，可以使用其中的類來進行大數(shù)運算、素數(shù)生成和驗證等。

• Crypto.Math.Primality：素數(shù)相關數(shù)學函數(shù)

• generate_probable_prime(exact_bits, randfunc, prime_filter)：用于生成一個指定位數(shù)的可能素數(shù)

exact_bits：生成素數(shù)的位數(shù)。
randfunc：一個隨機數(shù)生成函數(shù)，用于生成隨機數(shù)。
prime_filter：一個可選的函數(shù)，用于過濾掉不符合特定條件的候選素數(shù)。 

• generate_probable_safe_prime(exact_bits, randfunc)：用于生成一個指定位數(shù)的可能安全素數(shù)

exact_bits：生成素數(shù)的位數(shù)。
randfunc：一個隨機數(shù)生成函數(shù)，用于生成隨機數(shù)。 

• Crypto.Math.Numbers：數(shù)字相關數(shù)學函數(shù)

• numbers = Numbers.Integer(2)：創(chuàng)建Numbers對象
• numbers.ize_in_bytes()：返回整數(shù)的字節(jié)大小。
• numbers.size_in_bits()：返回整數(shù)的位數(shù)。
• numbers.set(source)：將整數(shù)設置為給定的值。
• numbers.random(**kwargs)：生成一個隨機的整數(shù)。
• numbers.random_range(**kwargs)：生成一個指定范圍內的隨機整數(shù)。
• numbers.sqrt(modulus)：計算整數(shù)的平方根模 modulus。
• numbers.lcm(term)：計算整數(shù)與給定項 term 的最小公倍數(shù)。
• numbers.gcd(term)：計算整數(shù)與給定項 term 的最大公約數(shù)。
• numbers.fail_if_divisible_by(small_prime)：如果整數(shù)可以被給定的小質數(shù) small_prime 整除，則引發(fā)異常。
• numbers.from_bytes(byte_string, byteorder)：將字節(jié)字符串轉換為整數(shù)。
• numbers.get_bit()：返回整數(shù)的最低有效位。
• numbers.inplace_inverse(modulus)：計算整數(shù)在模 modulus 下的乘法逆元并修改原始整數(shù)。
• numbers.inverse(modulus)：計算整數(shù)在模 modulus 下的乘法逆元。
• numbers.is_odd()：檢查整數(shù)是否為奇數(shù)。
• numbers.is_even()：檢查整數(shù)是否為偶數(shù)。
• numbers.inplace_pow(exponent, modulus)：計算整數(shù)的冪次方并修改原始整數(shù)。
• numbers.is_negative()：檢查整數(shù)是否為負數(shù)。
• numbers.is_perfect_square()：檢查整數(shù)是否為完全平方數(shù)。

到此這篇關于python中pycryptodome模塊實現(xiàn)加密算法庫的文章就介紹到這了,更多相關python pycryptodome加密內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！