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模式是一种认证加密模式,它提供了加密、解密和消息完整性验证的功能,并允许使用相同的密钥对多个消息进行加密,而不会泄漏关于明文的信息。
  1. 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 是一种认证加密模式,同时提供加密和认证功能。
  1. 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。当加密器对象的缓冲区中的数据被消耗完之后,会自动重新生成新的密钥流并填充缓冲区。
  1. 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 加密算法的电子密码本模式。在该模式下,每个明文分组都会独立地进行加密。
  1. 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 加密算法的密码反馈模式。在该模式下,明文分组的一部分会被加密,然后与明文分组的下一部分进行异或运算。
  1. 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 字节。
  1. 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 模式下,每个明文分组先与前一个密文分组进行异或运算,然后再进行加密。
  1. 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):用于调整密钥的奇偶校验位,确保密钥的正确性。
  1. 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 加密器和解密器对象时,可以将其用作哈希算法的参数类型。
  1. 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 加密器和解密器对象时,可以将其用作明文和密文的参数类型。
  1. 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())
  1. 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())
  1. 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())
  1. 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())
  1. 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())
  1. 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())
  1. 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())
  1. 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())
  1. 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())
  1. 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())
  1. 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())
  1. 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())
  1. 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))
  1. 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))
  1. 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()))
  1. 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())
  1. 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())

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


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

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

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

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

  1. 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))
  1. 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))
  1. 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 是密钥的密码(如果有的话)。
  1. 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 是一个布尔值,表示是否进行一致性检查。
  1. 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(私钥)等。
  1. 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):随机打乱可变序列(例如列表),直接修改原始序列直接修改原始序列
  1. Crypto.Random.get_random_bytes(n):生成一个包含n个随机字节的字节串
  2. Crypto.Random.getrandbits(k):生成一个k位的随机整数==
  3. 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'。
  1. 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 转换为长整数。
  1. 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)
  1. 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:一个随机数生成函数,用于生成随机数。
  1. 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():检查整数是否为完全平方数。

你可能感兴趣的:(python,python,开发语言)