网站建设公司企业文化,网推渠道,建设网站的公司兴田德润可以吗,企业信用信息公示系统年报怎么填一、简介
PyCryptodome是PyCrypto库的一个分支#xff0c;它是Python中最受欢迎的密码学库之一。PyCryptodome提供了许多密码学算法和协议的实现#xff0c;包括对称加密、非对称加密、消息摘要、密码哈希、数字签名等。它还提供了一些其他功能#xff0c;如密码学安全随机…一、简介
PyCryptodome是PyCrypto库的一个分支它是Python中最受欢迎的密码学库之一。PyCryptodome提供了许多密码学算法和协议的实现包括对称加密、非对称加密、消息摘要、密码哈希、数字签名等。它还提供了一些其他功能如密码学安全随机数生成、密码学文件格式的支持等。PyCryptodome的设计目标是提供高性能和可移植性。 如果你需要更高的性能和可移植性那么PyCryptodome可能更适合你。如果你注重安全性和易用性并且希望遵循最佳实践那么Cryptography可能是一个不错的选择。
二、安装
pip install pycryptodome三、pycryptodome之Crypto.Cipher
提供了对称加密算法的实现。可以使用其中的类来创建加密器和解密器支持常见的对称加密算法如AES、DES、Triple DES等。
Crypto.Cipher.AES对称加密算法支持不同的密钥长度128位、192位和256位。它是目前广泛使用的加密算法之一。
AES.new(key, mode, use_aesni)创建一个AES加密器/解密器对象 key表示用于加密和解密的密钥。它应该是一个字节串bytes类型长度可以是16、24或32字节对应于AES-128、AES-192和AES-256的密钥长度。
mode表示加密模式。它应该是AES.MODE_XXX常量之一如AES.MODE_ECB、AES.MODE_CBC等。
use_aesni一个布尔值表示是否使用AES-NI硬件指令集加速加密和解密操作。默认值为True。from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpadkey get_random_bytes(16)# 生成随机的16字节密钥plaintext bHello, 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_CCMCCM模式是一种组合模式它将CTR模式和CBC-MAC密码分组链接消息认证码组合在一起。它提供了加密、解密和消息完整性验证的功能。AES.MODE_CFBCFB模式将前一个密文块作为密钥流的一部分然后与明文进行异或操作产生密文。类似于CBC模式需要一个初始向量IV。AES.MODE_CTRCTR模式中明文与一个计数器进行异或操作生成密文。计数器可以是递增的也可以是随机的只要在加密和解密过程中保持一致即可。AES.MODE_EAXEAX模式是一种组合模式它将CTR模式和CMAC密码分组链接消息认证码组合在一起。它提供了加密、解密和消息完整性验证的功能。AES.MODE_GCMGCM模式是一种组合模式它将CTR模式和GMACGalois消息认证码组合在一起。它提供了加密、解密和消息完整性验证的功能。AES.MODE_OCBOCB模式是一种组合模式它将CTR模式和CMAC组合在一起并引入了一种效率更高的计算方式。它提供了加密、解密和消息完整性验证的功能。AES.MODE_OFBOFB模式将前一个密文块作为密钥流的一部分然后与明文进行异或操作产生密文。类似于CFB模式不需要初始向量IV。AES.MODE_OPENPGPOpenPGP模式是一种扩展的加密模式用于与OpenPGP协议兼容的系统。AES.MODE_SIVSIV模式是一种认证加密模式它提供了加密、解密和消息完整性验证的功能并允许使用相同的密钥对多个消息进行加密而不会泄漏关于明文的信息。
Crypto.Cipher.ARC2对称加密算法密钥长度可变通常为40位。它是一种较旧的加密算法现在很少使用。
ARC2.new(key,mode,iv,IV,nonce,segment_size,mac_len, initial_value,counter)创建一个ARC2加密器/解密器对象 keyARC2 加密算法使用的密钥。它应该是一个字节字符串并且长度必须在 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,unpadkey get_random_bytes(16) # 生成随机密钥
plaintext bHello, 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_sizeARC2 算法的块大小以字节为单位。在 pycryptodome 中ARC2 的块大小为 8 字节。ARC2.key_sizeARC2 算法支持的密钥长度以字节为单位。在 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_OPENPGPOpenPGP 模式。在 OpenPGP 模式下使用了特定的密钥派生函数和密钥流生成算法。ARC2.MODE_EAXEAX 模式。EAX 是一种认证加密模式同时提供加密和认证功能。
Crypto.Cipher.ARC4对称加密算法也被称为RC4。它是一种流密码算法密钥长度可变。它简单高效但由于一些安全性问题现在不推荐使用。
ARC4.new(key,drop)创建一个ARC4加密器/解密器对象 key表示要使用的密钥。密钥是一个字节串bytes长度可以根据需要进行调整。通常情况下密钥的长度应该与算法要求的密钥长度相匹配。
drop表示在生成初始密钥流之前要丢弃的初始字节数。这个参数是可选的默认值为 0。在某些应用中可以选择在开始加密之前丢弃一些初始字节以增加密钥流的随机性。from Crypto.Cipher import ARC4
from Crypto.Random import get_random_byteskey get_random_bytes(16) # 生成随机密钥
plaintext bHello, 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.BufferRC4 算法内部使用的缓冲区大小。在 pycryptodome 中这个值默认为 4096。当加密器对象的缓冲区中的数据被消耗完之后会自动重新生成新的密钥流并填充缓冲区。
Crypto.Cipher.Blowfish对称加密算法密钥长度可变。它是一种快速且安全的加密算法适用于各种应用场景。
Blowfish.new(key,mode,iv,IV,nonce,segment_size,mac_len ,initial_value,counter) 创建一个Blowfish加密器/解密器对象 key表示要使用的密钥。密钥是一个字节串bytes长度可以根据需要进行调整。Blowfish 算法支持的密钥长度可以是 8 到 448 位之间的任意长度。
mode表示加密模式。这个参数是可选的默认值为 MODE_ECB表示使用电子密码本模式。其他可选的模式包括 MODE_CBC密码分组链接模式和 MODE_CFB密码反馈模式等。
iv 或 IV表示初始化向量。这个参数是可选的用于在加密过程中增加随机性。对于 ECB 模式不需要提供初始化向量对于其他模式通常需要提供一个与块大小相匹配的初始化向量。
nonce表示使用的随机数。这个参数是可选的用于在加密过程中增加随机性。通常与 CTR 模式一起使用。
segment_size表示 CFB 模式中的分段大小。这个参数是可选的默认值为 8。在 CFB 模式中明文被分成固定大小的分段进行加密。
mac_len表示消息认证码的长度。这个参数是可选的默认值为 None表示不使用消息认证码。
initial_value表示初始值。这个参数是可选的用于在某些模式下设置初始值。
counter表示计数器的初始值。这个参数是可选的用于在 CTR 模式下设置计数器的初始值。from Crypto.Cipher import Blowfish
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpadkey get_random_bytes(16) # 生成随机密钥
plaintext bHello, World! # 要加密的明文# 创建 Blowfish 加密器对象使用 CBC 模式和随机的初始化向量
cipher Blowfish.new(key, modeBlowfish.MODE_CBC, ivget_random_bytes(8))
padded_plaintext pad(plaintext, cipher.block_size) # 填充明文数据
ciphertext cipher.encrypt(padded_plaintext) # 加密明文decipher Blowfish.new(key, modeBlowfish.MODE_CBC, ivcipher.iv) # 创建 Blowfish 加密器对象
decrypted decipher.decrypt(ciphertext) # 解密数据
decrypted_data unpad(decrypted, cipher.block_size) # 去除填充print(原始数据:, plaintext)
print(加密后:, ciphertext.hex())
print(解密后:, decrypted_data)
Blowfish.block_sizeBlowfish 算法的分组大小以字节为单位。对于 Blowfish 算法分组大小固定为 8 字节。Blowfish.BufferBlowfish 加密器对象的内部缓冲区的大小以字节为单位。在 pycryptodome 中默认的缓冲区大小为 4096 字节。Blowfish.key_sizeBlowfish 算法支持的密钥长度以位为单位。对于 Blowfish 算法密钥长度可以是 32 到 448 位之间的任意长度。Blowfish.MODE_CBCBlowfish 加密算法的密码分组链接模式。在该模式下每个明文分组在加密之前会与前一个密文分组进行异或运算。Blowfish.MODE_CFBBlowfish 加密算法的密码反馈模式。在该模式下明文分组的一部分会被加密然后与明文分组的下一部分进行异或运算。Blowfish.MODE_CTRBlowfish 加密算法的计数器模式。在该模式下明文分组会与计数器进行加密计数器的值会根据分组的索引逐渐递增。Blowfish.MODE_EAXBlowfish 加密算法的 EAX 模式。在该模式下可以同时进行加密和消息认证并提供附加数据的完整性验证。Blowfish.MODE_OFBBlowfish 加密算法的输出反馈模式。在该模式下密钥流会被生成并与明文分组进行异或运算然后输出密文。Blowfish.MODE_OPENPGPBlowfish 加密算法的 OpenPGP 模式。该模式与 CFB 模式类似但使用了不同的填充和反馈函数。Blowfish.MODE_ECBBlowfish 加密算法的电子密码本模式。在该模式下每个明文分组都会独立地进行加密。
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, unpadkey get_random_bytes(16) # 生成随机密钥
plaintext bHello, World! # 要加密的明文# 创建 CAST 加密器对象使用 CBC 模式和随机的初始化向量
cipher CAST.new(key, modeCAST.MODE_CBC, ivget_random_bytes(8))
padded_plaintext pad(plaintext, cipher.block_size) # 填充明文数据
ciphertext cipher.encrypt(padded_plaintext) # 加密明文decipher CAST.new(key, modeCAST.MODE_CBC, ivcipher.iv) # 创建 CAST 加密器对象
decrypted decipher.decrypt(ciphertext) # 解密数据
decrypted_data unpad(decrypted, cipher.block_size) # 去除填充print(原始数据:, plaintext)
print(加密后:, ciphertext.hex())
print(解密后:, decrypted_data)
CAST.block_sizeCAST 算法的分组大小以字节为单位。对于 CAST 算法分组大小固定为 8 字节。CAST.key_sizeCAST 算法支持的密钥长度以位为单位。对于 CAST 算法密钥长度可以是 40 位到 128 位之间的任意长度。CAST.BufferCAST 加密器对象的内部缓冲区的大小以字节为单位。在 pycryptodome 中默认的缓冲区大小为 4096 字节。CAST.MODE_CBCCAST 加密算法的密码分组链接模式。在该模式下每个明文分组在加密之前会与前一个密文分组进行异或运算。CAST.MODE_ECBCAST 加密算法的电子密码本模式。在该模式下每个明文分组都会独立地进行加密。CAST.MODE_OPENPGPCAST 加密算法的 OpenPGP 模式。该模式与 CFB 模式类似但使用了不同的填充和反馈函数。CAST.MODE_OFBCAST 加密算法的输出反馈模式。在该模式下密钥流会被生成并与明文分组进行异或运算然后输出密文。CAST.MODE_EAXCAST 加密算法的 EAX 模式。在该模式下可以同时进行加密和消息认证并提供附加数据的完整性验证。CAST.MODE_CTRCAST 加密算法的计数器模式。在该模式下明文分组会与计数器进行加密计数器的值会根据分组的索引逐渐递增。CAST.MODE_CFBCAST 加密算法的密码反馈模式。在该模式下明文分组的一部分会被加密然后与明文分组的下一部分进行异或运算。
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(keykey, noncenonce)# 创建 ChaCha20 加密器对象
plaintext bHello, World!# 要加密的明文
ciphertext cipher.encrypt(plaintext) # 加密明文decrypt_cipher ChaCha20.new(keykey, noncenonce) # 创建新的 ChaCha20 加密器对象使用相同的密钥和 nonce
decrypted_data decrypt_cipher.decrypt(ciphertext) # 解密密文print(原始数据:, plaintext)
print(加密后:, ciphertext.hex())
print(解密后:, decrypted_data)ChaCha20.block_sizeChaCha20 算法的分组大小以字节为单位。对于 ChaCha20 算法分组大小固定为 64 字节。ChaCha20.key_sizeChaCha20 算法支持的密钥长度以位为单位。对于 ChaCha20 算法密钥长度固定为 256 位。ChaCha20.BufferChaCha20 加密器对象的内部缓冲区的大小以字节为单位。在 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(keykey, noncenonce)# 创建 ChaCha20 加密器对象
plaintext bHello, World!# 要加密的明文
ciphertext cipher.encrypt(plaintext) # 加密明文decrypt_cipher ChaCha20_Poly1305.new(keykey, noncenonce) # 创建新的 ChaCha20 加密器对象使用相同的密钥和 nonce
decrypted_data decrypt_cipher.decrypt(ciphertext) # 解密密文print(原始数据:, plaintext)
print(加密后:, ciphertext.hex())
print(解密后:, decrypted_data)ChaCha20_Poly1305.block_sizeChaCha20_Poly1305 算法的分组大小以字节为单位。对于 ChaCha20_Poly1305 算法分组大小固定为 64 字节。ChaCha20_Poly1305.key_sizeChaCha20_Poly1305 算法支持的密钥长度以位为单位。对于 ChaCha20_Poly1305 算法密钥长度固定为 256 位。ChaCha20_Poly1305.BufferChaCha20_Poly1305 加密器对象的内部缓冲区的大小以字节为单位。在 pycryptodome 中默认的缓冲区大小为 4096 字节。
Crypto.Cipher.DES对称加密算法密钥长度为56位。它是一种较旧的加密算法现在不推荐使用。
DES.new(key,mode,iv,IV,nonce,segment_size,mac_len ,initial_value,counter)创建一个DES加密器/解密器对象 key要使用的密钥。密钥是一个字节串bytes长度固定为 8 字节。
mode加密模式。可以使用以下常量来指定加密模式
iv 或 IV初始化向量Initialization Vector。初始化向量是一个字节串bytes长度固定为 8 字节。在某些加密模式下如 CBC、CFB 和 OFB需要提供一个初始化向量。
nonce使用的随机数。这个参数是一个字节串bytes长度通常为 8 字节。在 CTR 模式下需要提供一个随机的 nonce。
segment_size分段大小以字节为单位。在 CFB 模式下可以指定分段大小取值范围为 1 到 8 之间的整数。
mac_len消息认证码的长度以字节为单位。在 CCM 和 EAX 模式下可以指定消息认证码的长度。
initial_value初始值。在 CTR 模式下可以指定初始值。
counter计数器的初始值。在 CTR 模式下可以指定计数器的初始值from Crypto.Cipher import DES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpadkey get_random_bytes(8) # 生成随机的8字节密钥plaintext bHello, 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_sizeDES 加密算法支持的密钥大小以位为单位。在 DES 中密钥大小固定为 56 位。DES.block_sizeDES 加密算法的分组大小以字节为单位。在 DES 中分组大小固定为 8 字节。DES.MODE_ECBDES 加密算法的电子密码本模式Electronic Codebook。在 ECB 模式下每个分组都独立地进行加密相同的明文分组将得到相同的密文分组。DES.MODE_CFBDES 加密算法的密码反馈模式Cipher Feedback。在 CFB 模式下前一个密文分组被反馈给加密器用于生成下一个密文分组。DES.MODE_CTRDES 加密算法的计数器模式Counter。在 CTR 模式下每个分组都使用一个唯一的计数器值进行加密计数器值通过加密器生成。DES.MODE_EAXDES 加密算法的 EAX 模式。EAX 模式提供了加密、认证和扩展性。DES.MODE_OFBDES 加密算法的输出反馈模式Output Feedback。在 OFB 模式下前一个密文分组被反馈给加密器用于生成密钥流然后与明文进行异或运算得到密文。DES.MODE_OPENPGPDES 加密算法的 OpenPGP 模式。DES.MODE_CBCDES 加密算法的密码分组链接模式Cipher Block Chaining。在 CBC 模式下每个明文分组先与前一个密文分组进行异或运算然后再进行加密。
Crypto.Cipher.DES3对称加密算法也被称为Triple DES。密钥长度为168位由3个56位的子密钥组成。它提供了较高的安全性但速度较慢。
DES3.new(key,mode,iv,IV,nonce,segment_size,mac_len ,initial_value,counter)创建一个DES3加密器/解密器对象 key表示要使用的密钥。密钥是一个字节串bytes长度必须为 16 或 24 字节。
mode表示加密模式。可以使用以下常量进行指定
iv 或 IV表示初始化向量。这个参数是一个字节串bytes长度必须为 8 字节。
nonce表示使用的随机数。这个参数是一个字节串bytes长度必须为 8 字节。
segment_size表示用于 CFB 模式的分段大小以位为单位。默认值为 8。
mac_len表示 EAX 模式中认证标签的长度以字节为单位。默认值为 8。
initial_value表示 CTR 模式中初始计数器值。这个参数是一个整数默认值为 0。from Crypto.Cipher import DES3
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpadkey get_random_bytes(24) # 生成随机的8字节密钥plaintext bHello, 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_sizeDES3 加密算法的分组大小以字节为单位。在 DES3 中分组大小固定为 8 字节。DES3.key_sizeDES3 加密算法支持的密钥大小以位为单位。在 DES3 中密钥大小可以是 128 位16 字节或 192 位24 字节。DES3.BufferDES3 加密算法的缓冲区大小以字节为单位。DES3.MODE_CBCDES3 加密算法的密码分组链接模式Cipher Block Chaining。在 CBC 模式下每个明文分组先与前一个密文分组进行异或运算然后再进行加密。DES3.MODE_ECBDES3 加密算法的电子密码本模式Electronic Codebook。在 ECB 模式下每个分组都独立地进行加密相同的明文分组将得到相同的密文分组。DES3.MODE_OPENPGPDES3 加密算法的 OpenPGP 模式。DES3.MODE_OFBDES3 加密算法的输出反馈模式Output Feedback。在 OFB 模式下前一个密文分组被反馈给加密器用于生成密钥流然后与明文进行异或运算得到密文。DES3.MODE_EAXDES3 加密算法的 EAX 模式。EAX 模式提供了加密、认证和扩展性。DES3.MODE_CTRDES3 加密算法的计数器模式Counter。在 CTR 模式下每个分组都使用一个唯一的计数器值进行加密计数器值通过加密器生成。DES3.MODE_CFBDES3 加密算法的密码反馈模式Cipher Feedback。在 CFB 模式下前一个密文分组被反馈给加密器用于生成下一个密文分组。DES3.adjust_key_parity(key_in)用于调整密钥的奇偶校验位确保密钥的正确性。
Crypto.Cipher.PKCS1_OAEP非对称加密算法使用OAEPOptimal Asymmetric Encryption Padding填充方案。它用于加密和解密数据通常与RSA密钥一起使用。
PKCS1_OAEP.new(key,hashAlgo,mgfunc,label,randfunc)创建一个PKCS1_OAEP加密器/解密器对象 keyRSA 密钥对象公钥或私钥。
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 SHA256key RSA.generate(2048) # 生成 RSA 密钥对
plaintext bHello, world! # 加密数据cipher PKCS1_OAEP.new(key, hashAlgoSHA256) # 创建 PKCS1_OAEP 加密器对象
ciphertext cipher.encrypt(plaintext) # 加密decrypt_cipher PKCS1_OAEP.new(key, hashAlgoSHA256) # 创建 PKCS1_OAEP 加密器对象
decrypted decrypt_cipher.decrypt(ciphertext) # 解密print(原始数据:, plaintext)
print(加密后:, ciphertext.hex())
print(解密后:, decrypted)
PKCS1_OAEP.Buffer 一个字节串bytes类型的缓冲区。在使用 PKCS1_OAEP 加密器和解密器对象时可以将其用作密钥、明文和密文的参数类型。PKCS1_OAEP.HashLike 一个类似于哈希对象的类型。在使用 PKCS1_OAEP 加密器和解密器对象时可以将其用作哈希算法的参数类型。
Crypto.Cipher.PKCS1_v1_5非对称加密算法使用PKCS#1 v1.5填充方案。它用于加密和解密数据通常与RSA密钥一起使用。
PKCS1_v1_5.new(key,randfunc)创建一个PKCS1_v1_5加密器/解密器对象 keyRSA 密钥对象可以是公钥或私钥。这个密钥对象用于进行加密或解密操作。
randfunc一个可调用对象用于生成随机数。如果提供了 randfunc它将被用于生成加密过程中需要的随机字节。如果未提供 randfunc则会使用默认的随机数生成器from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5key RSA.generate(2048) # 生成 RSA 密钥对
plaintext bHello, world! # 加密数据cipher PKCS1_v1_5.new(key) # 创建 PKCS1_v1_5 加密器对象
ciphertext cipher.encrypt(plaintext) # 加密decrypt_cipher PKCS1_v1_5.new(key) # 创建 PKCS1_v1_5 加密器对象
decrypted decrypt_cipher.decrypt(ciphertext, None) # 解密print(原始数据:, plaintext)
print(加密后:, ciphertext.hex())
print(解密后:, decrypted)PKCS1_v1_5.Buffer 一个字节串bytes类型的缓冲区。在使用 PKCS1_v1_5 加密器和解密器对象时可以将其用作明文和密文的参数类型。
Crypto.Cipher.Salsa20对称加密算法密钥长度为256位。它是一种高速的加密算法适用于资源受限的环境。
Salsa20.new(key,nonce)创建一个Salsa20加密器/解密器对象 keySalsa20 密钥一个字节串bytes类型的密钥。密钥长度可以是 16 字节128 位或 32 字节256 位。
nonceSalsa20 随机数一个字节串bytes类型的随机数。它用于与密钥一起生成加密流。
from Crypto.Cipher import Salsa20key b0123456789abcdef # 16 字节密钥
nonce b87654321 # 8 字节随机数plaintext bHello, 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_sizeSalsa20 密钥的长度单位为字节。在 pycryptodome 中Salsa20 密钥长度可以是 16 字节128 位或 32 字节256 位。Salsa20.block_sizeSalsa20 加密算法的块大小单位为字节。在 pycryptodome 中Salsa20 的块大小固定为 64 字节。
四、pycryptodome之Crypto.Hash
提供了哈希函数的实现。可以使用其中的类来计算消息的哈希值支持常见的哈希算法如MD5、SHA-1、SHA-256等。 1.Crypto.Hash.MD2MD2哈希算法
MD2.Buffer表示 MD2 哈希函数的缓冲区大小。MD2.block_size表示 MD2 哈希函数的输入块大小即每次处理的数据块大小。MD2.digest_size表示 MD2 哈希函数的输出摘要的字节大小。MD2.new(dataNone)用于创建一个新的 MD2 哈希对象
from Crypto.Hash import MD2data hello word.encode(utf-8)md2 MD2.new(data)print(十六进制哈希值,md2.hexdigest())
print(十六字节哈希值,md2.digest())
print(哈希算法的分块大小,md2.block_size)
print(哈希算法的哈希值大小,md2.digest_size)
print(拷贝当前哈希对象,md2.copy())md2.update(hello.encode(utf-8))print(十六进制哈希值,md2.hexdigest())Crypto.Hash.MD4MD4哈希算法
MD4.Buffer表示 MD4 哈希函数的缓冲区大小。MD4.block_size表示 MD4 哈希函数的输入块大小即每次处理的数据块大小。MD4.digest_size表示 MD4 哈希函数的输出摘要的字节大小。MD4.new(dataNone)用于创建一个新的 MD4 哈希对象
from Crypto.Hash import MD4data hello word.encode(utf-8)md4 MD4.new(data)print(十六进制哈希值,md4.hexdigest())
print(十六字节哈希值,md4.digest())
print(哈希算法的分块大小,md4.block_size)
print(哈希算法的哈希值大小,md4.digest_size)
print(拷贝当前哈希对象,md4.copy())md4.update(hello.encode(utf-8))print(十六进制哈希值,md4.hexdigest())Crypto.Hash.MD5MD5哈希算法
MD5.Buffer表示 MD5 哈希函数的缓冲区大小。MD5.block_size表示 MD5 哈希函数的输入块大小即每次处理的数据块大小。MD5.digest_size表示 MD5 哈希函数的输出摘要的字节大小。MD5.new(dataNone)用于创建一个新的 MD5 哈希对象
from Crypto.Hash import MD5data hello word.encode(utf-8)md5 MD5.new(data)print(十六进制哈希值,md5.hexdigest())
print(十六字节哈希值,md5.digest())
print(哈希算法的分块大小,md5.block_size)
print(哈希算法的哈希值大小,md5.digest_size)
print(拷贝当前哈希对象,md5.copy())md5.update(hello.encode(utf-8))print(十六进制哈希值,md5.hexdigest())Crypto.Hash.SHA256SHA256哈希算法
SHA256.Buffer表示 SHA256 哈希函数的缓冲区大小。SHA256.block_size表示 SHA256 哈希函数的输入块大小即每次处理的数据块大小。SHA256.digest_size表示 SHA256 哈希函数的输出摘要的字节大小。SHA256.new(dataNone)用于创建一个新的 SHA256 哈希对象
from Crypto.Hash import SHA256data hello word.encode(utf-8)sha256 SHA256.new(data)print(十六进制哈希值,sha256.hexdigest())
print(十六字节哈希值,sha256.digest())
print(哈希算法的分块大小,sha256.block_size)
print(哈希算法的哈希值大小,sha256.digest_size)
print(拷贝当前哈希对象,sha256.copy())sha256.update(hello.encode(utf-8))print(十六进制哈希值,sha256.hexdigest())Crypto.Hash.SHA1SHA1哈希算法
SHA1.Buffer表示 SHA1 哈希函数的缓冲区大小。SHA1.block_size表示 SHA1 哈希函数的输入块大小即每次处理的数据块大小。SHA1.digest_size表示 SHA1 哈希函数的输出摘要的字节大小。SHA1.new(dataNone)用于创建一个新的 SHA1 哈希对象
from Crypto.Hash import SHA1data hello word.encode(utf-8)sha1 SHA1.new(data)print(十六进制哈希值,sha1.hexdigest())
print(十六字节哈希值,sha1.digest())
print(哈希算法的分块大小,sha1.block_size)
print(哈希算法的哈希值大小,sha1.digest_size)
print(拷贝当前哈希对象,sha1.copy())sha1.update(hello.encode(utf-8))print(十六进制哈希值,sha1.hexdigest())Crypto.Hash.SHA224SHA224哈希算法
SHA224.Buffer表示 SHA224 哈希函数的缓冲区大小。SHA224.block_size表示 SHA224 哈希函数的输入块大小即每次处理的数据块大小。SHA224.digest_size表示 SHA224 哈希函数的输出摘要的字节大小。SHA224.new(dataNone)用于创建一个新的 SHA224 哈希对象
from Crypto.Hash import SHA224data hello word.encode(utf-8)sha224 SHA224.new(data)print(十六进制哈希值,sha224.hexdigest())
print(十六字节哈希值,sha224.digest())
print(哈希算法的分块大小,sha224.block_size)
print(哈希算法的哈希值大小,sha224.digest_size)
print(拷贝当前哈希对象,sha224.copy())sha224.update(hello.encode(utf-8))print(十六进制哈希值,sha224.hexdigest())Crypto.Hash.SHA384SHA384哈希算法
SHA384.Buffer表示 SHA384 哈希函数的缓冲区大小。SHA384.block_size表示 SHA384 哈希函数的输入块大小即每次处理的数据块大小。SHA384.digest_size表示 SHA384 哈希函数的输出摘要的字节大小。SHA384.new(dataNone)用于创建一个新的 SHA384 哈希对象
from Crypto.Hash import SHA384data hello word.encode(utf-8)sha384 SHA384.new(data)print(十六进制哈希值,sha384.hexdigest())
print(十六字节哈希值,sha384.digest())
print(哈希算法的分块大小,sha384.block_size)
print(哈希算法的哈希值大小,sha384.digest_size)
print(拷贝当前哈希对象,sha384.copy())sha384.update(hello.encode(utf-8))print(十六进制哈希值,sha384.hexdigest())Crypto.Hash.SHA512SHA512哈希算法
SHA512.Buffer表示 SHA512 哈希函数的缓冲区大小。SHA512.block_size表示 SHA512 哈希函数的输入块大小即每次处理的数据块大小。SHA512.digest_size表示 SHA512 哈希函数的输出摘要的字节大小。SHA512.new(dataNone)用于创建一个新的 SHA512 哈希对象
from Crypto.Hash import SHA512data hello word.encode(utf-8)sha512 SHA512.new(data)print(十六进制哈希值,sha512.hexdigest())
print(十六字节哈希值,sha512.digest())
print(哈希算法的分块大小,sha512.block_size)
print(哈希算法的哈希值大小,sha512.digest_size)
print(拷贝当前哈希对象,sha512.copy())sha512.update(hello.encode(utf-8))print(十六进制哈希值,sha512.hexdigest())Crypto.Hash.SHA3_224SHA3_224哈希算法
SHA3_224.Buffer表示 SHA3_224 哈希函数的缓冲区大小。SHA3_224.block_size表示 SHA3_224 哈希函数的输入块大小即每次处理的数据块大小。SHA3_224.digest_size表示 SHA3_224 哈希函数的输出摘要的字节大小。SHA3_224.new(dataNone,update_after_digest)用于创建一个新的 SHA3_224 哈希对象
from Crypto.Hash import SHA3_224data hello word.encode(utf-8)sha3_224 SHA3_224.new(data,update_after_digestTrue)print(十六进制哈希值,sha3_224.hexdigest())
print(十六字节哈希值,sha3_224.digest())
print(哈希算法的分块大小,sha3_224.block_size)
print(哈希算法的哈希值大小,sha3_224.digest_size)
print(拷贝当前哈希对象,sha3_224.copy())sha3_224.update(hello.encode(utf-8))print(十六进制哈希值,sha3_224.hexdigest())Crypto.Hash.SHA3_256SHA3_256哈希算法
SHA3_256.Buffer表示 SHA3_256 哈希函数的缓冲区大小。SHA3_256.block_size表示 SHA3_256 哈希函数的输入块大小即每次处理的数据块大小。SHA3_256.digest_size表示 SHA3_256 哈希函数的输出摘要的字节大小。SHA3_256.new(dataNone,update_after_digest)用于创建一个新的 SHA3_256 哈希对象
from Crypto.Hash import SHA3_256data hello word.encode(utf-8)sha3_256 SHA3_256.new(data,update_after_digestTrue)print(十六进制哈希值,sha3_256.hexdigest())
print(十六字节哈希值,sha3_256.digest())
print(哈希算法的分块大小,sha3_256.block_size)
print(哈希算法的哈希值大小,sha3_256.digest_size)
print(拷贝当前哈希对象,sha3_256.copy())sha3_256.update(hello.encode(utf-8))print(十六进制哈希值,sha3_256.hexdigest())Crypto.Hash.SHA3_384SHA3_384哈希算法
SHA3_384.Buffer表示 SHA3_384 哈希函数的缓冲区大小。SHA3_384.block_size表示 SHA3_384 哈希函数的输入块大小即每次处理的数据块大小。SHA3_384.digest_size表示 SHA3_384 哈希函数的输出摘要的字节大小。SHA3_384.new(dataNone,update_after_digest)用于创建一个新的 SHA3_384 哈希对象
from Crypto.Hash import SHA3_384data hello word.encode(utf-8)sha3_384 SHA3_384.new(data,update_after_digestTrue)print(十六进制哈希值,sha3_384.hexdigest())
print(十六字节哈希值,sha3_384.digest())
print(哈希算法的分块大小,sha3_384.block_size)
print(哈希算法的哈希值大小,sha3_384.digest_size)
print(拷贝当前哈希对象,sha3_384.copy())sha3_384.update(hello.encode(utf-8))print(十六进制哈希值,sha3_384.hexdigest())Crypto.Hash.SHA3_512SHA3_512哈希算法
SHA3_512.Buffer表示 SHA3_512 哈希函数的缓冲区大小。SHA3_512.block_size表示 SHA3_512 哈希函数的输入块大小即每次处理的数据块大小。SHA3_512.digest_size表示 SHA3_512 哈希函数的输出摘要的字节大小。SHA3_512.new(dataNone,update_after_digest)用于创建一个新的 SHA3_512 哈希对象
from Crypto.Hash import SHA3_512data hello word.encode(utf-8)sha3_512 SHA3_512.new(data,update_after_digestTrue)print(十六进制哈希值,sha3_512.hexdigest())
print(十六字节哈希值,sha3_512.digest())
print(哈希算法的分块大小,sha3_512.block_size)
print(哈希算法的哈希值大小,sha3_512.digest_size)
print(拷贝当前哈希对象,sha3_512.copy())sha3_512.update(hello.encode(utf-8))print(十六进制哈希值,sha3_512.hexdigest())Crypto.Hash.SHAKE128SHAKE128哈希算法SHA-3 衍生的可变长度哈希函数可以生成不同长度的哈希值
SHAKE128.BufferSHAKE128 哈希函数的缓冲区大小。SHAKE128.new(data)创建一个新的 SHAKE128 哈希对象。
from Crypto.Hash import SHAKE128data bhello wordshake128 SHAKE128.new(data)shake128.update(bhello)print(字节哈希值, shake128.read(10))Crypto.Hash.SHAKE256SHAKE256哈希算法SHA-3 衍生的可变长度哈希函数可以生成不同长度的哈希值
SHAKE256.BufferSHAKE256 哈希函数的缓冲区大小。SHAKE256.new(data)创建一个新的 SHAKE256 哈希对象。
from Crypto.Hash import SHAKE256data bhello wordshake256 SHAKE256.new(data)shake256.update(bhello)print(字节哈希值, shake256.read(10))Crypto.Hash.HMAC这是基于哈希函数的密钥相关的消息认证码算法。它可以使用不同的哈希算法如 SHA256、SHA512 等来计算消息认证码。
HMAC.Buffer表示 HMAC 哈希函数的缓冲区大小。HMAC.digest_size表示 HMAC 哈希函数输出的摘要哈希值的大小以字节为单位。HMAC.new(key, msg, digestmod)创建一个新的 HMAC 哈希对象 key密钥
msg消息
digestmod哈希算法常见的哈希算法包括 SHA1、SHA256、SHA512 等。from Crypto.Hash import HMAC,MD5key bmy_secret_key
message bHello, world!hmac HMAC.new(key,message,MD5)print(十六进制哈希值,hmac.hexdigest())
print(十六字节哈希值,hmac.digest())
print(哈希算法的哈希值大小,hmac.digest_size)
print(拷贝当前哈希对象,hmac.copy())
print(验证十六字节哈希值,hmac.verify(hmac.digest()))
print(验证十六进制哈希值,hmac.hexverify(hmac.hexdigest()))Crypto.Hash.CMAC这是一种基于对称加密算法的消息认证码算法。它使用一个密钥和一个块加密算法如 AES来计算消息认证码。
CMAC.Buffer是一个常量表示 CMAC 算法的缓冲区大小。CMAC.digest_size表示 CMAC 算法输出的摘要MAC 值的大小以字节为单位。CMAC.new(key, msg, ciphermod, cipher_params, mac_len, update_after_digest)用于创建一个新的 CMAC 算法对象 key表示用于计算 CMAC 的密钥是一个字节串。
msg表示要计算 CMAC 的消息也是一个字节串。
ciphermod表示底层使用的对称加密算法模块例如 Crypto.Cipher.AES、Crypto.Cipher.DES 等。
cipher_params表示底层对称加密算法的参数例如 AES 加密算法的参数可以是一个字节串表示的密钥。
mac_len表示期望的 MAC 长度以字节为单位。如果不指定默认为底层对称加密算法的块大小。
update_after_digest布尔值表示在计算完摘要后是否允许继续更新 CMAC 对象。如果为 True可以继续调用 update() 方法更新 CMAC 对象如果为 False在计算完摘要后调用 update() 方法将引发异常。默认为 False。from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Hash import CMACkey get_random_bytes(16) # 生成随机密钥
plaintext bHello, world! # 要加密的数据cmac CMAC.new(key, plaintext, ciphermodAES, mac_len8,update_after_digestTrue)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(bhello)
print(十六进制哈希值, cmac.hexdigest())Crypto.Hash.RIPEMD160RIPEMD160哈希算法
RIPEMD160.digest_sizeRIPEMD-160 哈希值的字节大小。RIPEMD160.block_sizeRIPEMD-160 算法的分块大小。RIPEMD160.BufferRIPEMD-160 哈希值的缓冲区。RIPEMD160.new(dataNone)创建一个新的 RIPEMD160 哈希对象 from Crypto.Hash import RIPEMD160data hello word.encode(utf-8)ripemd160 RIPEMD160.new(data)print(十六进制哈希值, ripemd160.hexdigest())
print(十六字节哈希值, ripemd160.digest())
print(哈希算法的分块大小, ripemd160.block_size)
print(哈希算法的哈希值大小, ripemd160.digest_size)
print(拷贝当前哈希对象, ripemd160.copy())ripemd160.update(hello.encode(utf-8))print(十六进制哈希值, ripemd160.hexdigest())
Crypto.Hash.KMAC128KMAC128哈希算法
KMAC128.Buffer KMAC128 哈希值的缓冲区。KMAC128.new(key, dataNone, mac_lenNone, customNone)创建一个新的 KMAC128 哈希对象 key密钥。它是一个字节串bytes用于计算哈希值和认证标签。
data要计算哈希值的数据。它是一个字节串bytes。
mac_len期望的哈希值的长度以比特为单位。如果未指定将使用默认的哈希值长度。
custom自定义字符串用于与密钥一起计算哈希值和认证标签。它是一个字节串bytesfrom Crypto.Hash import KMAC128
from Crypto.Random import get_random_byteskey get_random_bytes(16) # 密钥
data bHello, world! # 要计算哈希值的数据
mac_len 16 # MAC 长度
custom bcustom_string # 自定义字符串kmac128 KMAC128.new(keykey, datadata, mac_lenmac_len, customcustom)# kmac128.update(bhello)print(十六进制哈希值, kmac128.hexdigest())
print(十六字节哈希值, kmac128.digest())
print(验证十六字节哈希值, kmac128.verify(kmac128.digest()))
print(验证十六进制哈希值, kmac128.hexverify(kmac128.hexdigest()))
Crypto.Hash.KMAC256这些是基于 Keccak 算法的可变长度哈希函数可以生成不同长度的哈希值。
KMAC256.BufferKMAC128 哈希值的缓冲区。KMAC256.new(key, dataNone, mac_lenNone, customNone)创建一个新的 KMAC256 哈希对象 key密钥。它是一个字节串bytes用于计算哈希值和认证标签。
data要计算哈希值的数据。它是一个字节串bytes。
mac_len期望的哈希值的长度以比特为单位。如果未指定将使用默认的哈希值长度。
custom自定义字符串用于与密钥一起计算哈希值和认证标签。它是一个字节串bytesfrom Crypto.Hash import KMAC256
from Crypto.Random import get_random_byteskey get_random_bytes(32) # 密钥
data bHello, world! # 要计算哈希值的数据
mac_len 32 # MAC 长度
custom bcustom_string # 自定义字符串kmac256 KMAC256.new(keykey, datadata, mac_lenmac_len, customcustom)# kmac256.update(bhello)print(十六进制哈希值, kmac256.hexdigest())
print(十六字节哈希值, kmac256.digest())
print(验证十六字节哈希值, kmac256.verify(kmac256.digest()))
print(验证十六进制哈希值, kmac256.hexverify(kmac256.hexdigest()))
Crypto.Hash.TupleHash128基于 Keccak 算法的元组哈希函数用于将多个输入值组合成单个哈希值
TupleHash128.BufferTupleHash128 哈希值的缓冲区。TupleHash128.new(digest_bytes,digest_bits,custom)创建一个新的 TupleHash128 哈希对象 digest_bytes必要计算哈希值的数据。它是一个字节串bytes。
digest_bits期望的哈希值的长度以比特为单位。
custom自定义字符串用于计算哈希值。它是一个字节串bytesfrom Crypto.Hash import TupleHash128custom bHello, world! # 消息数据tulphash128 TupleHash128.new(digest_bytes32,customcustom)tulphash128.update(bhello)print(十六进制哈希值, tulphash128.hexdigest())
print(十六字节哈希值, tulphash128.digest())Crypto.Hash.TupleHash256这些是基于 Keccak 算法的元组哈希函数用于将多个输入值组合成单个哈希值。
TupleHash256.BufferTupleHash256 哈希值的缓冲区。TupleHash256.new(digest_bytes,digest_bits,custom)创建一个新的 TupleHash256 哈希对象 digest_bytes必要计算哈希值的数据。它是一个字节串bytes。
digest_bits期望的哈希值的长度以比特为单位。
custom自定义字符串用于计算哈希值。它是一个字节串bytesfrom Crypto.Hash import TupleHash256custom bHello, world! # 消息数据tulphash256 TupleHash256.new(digest_bytes32,customcustom)tulphash256.update(bhello)print(十六进制哈希值, tulphash256.hexdigest())
print(十六字节哈希值, tulphash256.digest())Crypto.Hash.BLAKE2sBLAKE2 系列的哈希函数提供高速和安全的哈希计算
BLAKE2s.BufferBLAKE2s 哈希值的缓冲区。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_byteskey get_random_bytes(32) # 密钥
data bHello, world! # 要计算哈希值的数据
digest_bits 32 # MAC 长度
custom bcustom_string # 自定义字符串blake2s BLAKE2s.new(datadata,digest_bytes32,keykey,update_after_digestTrue)print(十六进制哈希值, blake2s.hexdigest())
print(十六字节哈希值, blake2s.digest())
print(验证十六字节哈希值, blake2s.verify(blake2s.digest()))
print(验证十六进制哈希值, blake2s.hexverify(blake2s.hexdigest()))blake2s.update(bhello)
print(十六进制哈希值, blake2s.hexdigest())
Crypto.Hash.BLAKE2bBLAKE2 系列的哈希函数提供高速和安全的哈希计算
BLAKE2b.BufferBLAKE2b 哈希值的缓冲区。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_byteskey get_random_bytes(32) # 密钥
data bHello, world! # 要计算哈希值的数据
digest_bits 32 # MAC 长度
custom bcustom_string # 自定义字符串blake2b BLAKE2b.new(datadata,digest_bytes32,keykey,update_after_digestTrue)print(十六进制哈希值, blake2b.hexdigest())
print(十六字节哈希值, blake2b.digest())
print(验证十六字节哈希值, blake2b.verify(blake2b.digest()))
print(验证十六进制哈希值, blake2b.hexverify(blake2b.hexdigest()))blake2b.update(bhello)
print(十六进制哈希值, blake2b.hexdigest())
Crypto.Hash.KangarooTwelve这是一种快速的哈希函数适用于各种应用场景。
KangarooTwelve.BufferKangarooTwelve 哈希值的缓冲区。 data要计算哈希值的数据。它可以是字节串bytes、字节数组bytearray或可迭代对象例如字符串。如果是可迭代对象它将在计算哈希值之前被转换为字节串。
custom可选的自定义字符串。它是一个字节串bytes用于在计算哈希值时添加自定义的上下文信息。如果不提供 custom 参数则默认为 Nonefrom Crypto.Hash import KangarooTwelvedata bHello, world! # 消息数据
custom bHello, world! # 消息数据kangarootwelve KangarooTwelve.new(data,custom)# kangarootwelve.update(bhello)print(十六进制哈希值, kangarootwelve.read(36))Crypto.Hash.Poly1305这是一种消息认证码算法用于计算消息的认证标签。
Poly1305.BufferPoly1305 哈希值的缓冲区。Poly1305.new(key, cipher, nonce, data)创建一个新的Poly1305 哈希对象 key用于计算认证标签的密钥。它是一个字节串bytes长度为 32 字节。Poly1305 算法要求密钥长度为 256 比特。
cipher用于加密消息的加密算法。它是一个可调用的加密函数接受两个参数密钥和 nonce。该函数将返回一个加密器对象用于加密数据。
nonce用于加密消息的一次性值。它是一个字节串bytes长度为 16 字节。每个消息都应该使用不同的 nonce 值以确保安全性。
data要计算认证标签的消息数据。它是一个字节串bytesfrom Crypto.Cipher import ChaCha20
from Crypto.Hash import Poly1305
from Crypto.Random import get_random_byteskey get_random_bytes(32) # 密钥
nonce get_random_bytes(12) # 一次性值
data bHello, world! # 消息数据cipher ChaCha20.new(keykey, noncenonce) # 创建 ChaCha20 加密器
encrypted_data cipher.encrypt(data) # 加密消息数据POLY1305 Poly1305.new(keykey, cipherChaCha20, noncenonce, dataencrypted_data)# POLY1305.update(bhello)print(十六进制哈希值, POLY1305.hexdigest())
print(十六字节哈希值, POLY1305.digest())
print(验证十六字节哈希值, POLY1305.verify(POLY1305.digest()))
print(验证十六进制哈希值, POLY1305.hexverify(POLY1305.hexdigest()))
五、pycryptodome之Crypto.IO
提供了一些输入输出相关的功能。例如可以使用其中的类来进行文件的加密和解密操作。
Crypto.IO.PEM处理 PEMPrivacy-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 PEMdata bHello, world! # 待编码的数据pem_data PEM.encode(data, DATA) # 编码为 PEM 格式decoded_data PEM.decode(pem_data) # 解码EM 格式print(原数据, data)
print(编码后的数据, pem_data)
print(解码后的数据, decoded_data)
Crypto.IO.PKCS8处理 PKCS8格式的数据。PKCS8是一种标准的格式用于存储和传输公钥和私钥。PKCS8 模块可以用于读取、写入和解析 PKCS8格式的数据。
PKCS8.wrap(private_key,key_oid,passphrase,protection,prot_params,key_params,randfunc)将私钥包装为 PKCS8 格式的加密私钥信息
private_key: 要包装的私钥对象。可以是 Crypto.PublicKey.RSA、Crypto.PublicKey.DSA 或 Crypto.PublicKey.ECC 等类型的私钥对象。
key_oid: 表示私钥算法的对象标识符OID。默认值为 None表示使用默认的 OID。
passphrase: 用于加密私钥的密码短语passphrase。可以是字符串或字节串。
protection: 加密算法的标识符用于保护私钥数据。可以是字符串或字节串。常见的值包括 PBKDF2WithHMAC-SHA256AndAES256-CBC 和 PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC。
prot_params: 保护参数用于指定加密算法的参数。可以是字典或 None。
key_params: 私钥参数用于指定私钥的格式和编码方式。可以是字典或 None。
randfunc: 用于生成随机数据的随机数生成器函数。默认值为 None表示使用默认的随机数生成器。PKCS8.unwrap(p8_private_key, passphrase)解密包含有加密私钥信息的 PKCS8 格式数据 p8_private_key: 包含加密私钥信息的 PKCS#8 格式数据。可以是字节串或字符串。
passphrase: 解密私钥的密码短语passphrase。可以是字符串或字节串。六、pycryptodome之Crypto.Signature
提供了数字签名算法的实现。可以使用其中的类来进行数字签名和验证支持常见的数字签名算法
Crypto.Signature.PKCS1_v1_5PKCS1_v1_5 是一种经典的 RSA 签名方案使用 RSA 密钥对进行签名和验证。该方案在许多应用中广泛使用。 rsa_keyRSA 密钥对象。它可以是一个 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 MD5key RSA.generate(2048) # 生成 RSA 密钥对plaintext bHello, world! # 加密数据signer PKCS1_v1_5.new(key) # 创建 PKCS1_v1_5 验证对象# 数据data bHello, world!# 使用私钥进行签名hash_value MD5.new(data)
signature signer.sign(hash_value)verifier PKCS1_v1_5.new(key) # 创建 PKCS1_v1_5 验证对象print(验证密钥RSA密钥是否适用PKCS1_v1_5签名:, verifier.can_sign())
print(签名验证结果:, verifier.verify(hash_value, signature))Crypto.Signature.PKCS1_PSS使用 RSA 密钥对进行签名和验证PKCS1_PSS 是一种更现代的 RSA 签名方案提供更好的安全性和抗攻击性能。 rsa_keyRSA 密钥对象。它可以是一个 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 MD5key RSA.generate(2048) # 生成 RSA 密钥对
plaintext bHello, world! # 加密数据signer PKCS1_PSS.new(key) # 创建PKCS1_PSS验证对象# 数据
data bHello, world!# 使用私钥进行签名
hash_value MD5.new(data)
signature signer.sign(hash_value)verifier PKCS1_PSS.new(key) # 创建PKCS1_PSS验证对象print(验证密钥RSA密钥是否适用PKCS1_PSS签名:, verifier.can_sign())
print(签名验证结果:, verifier.verify(hash_value, signature))Crypto.Signature.DSS使用 DSA 密钥对进行签名和验证适用于需要较短签名长度和高性能的场景DSA 是一种非对称加密算法用于数字签名 keyDSA 密钥对象可以使用 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 SHA256key DSA.generate(2048) # 生成 DSA 密钥对
plaintext bHello, world! # 加密数据
mode fips-186-3signer DSS.new(key, mode) # 创建 DSS 签名对象hash_value SHA256.new(plaintext)
signature signer.sign(hash_value)verifier DSS.new(key, mode) # 创建 DSS 验证对象print(验证密钥 DSA 密钥是否适用 DSS 签名:, verifier.can_sign())
print(签名验证结果:, verifier.verify(hash_value, signature))七、pycryptodome之Crypto.PublicKey
提供了非对称加密算法公钥加密算法的实现。可以使用其中的类来生成密钥对、进行加密和解密操作支持常见的非对称加密算法如RSA、DSA等。
Crypto.PublicKey.RSARSA 提供了 RSA 密钥对的生成、加密和解密功能。
RSA.RsaKeyRsaKey 是一个类表示 RSA 密钥对。它是 RSA 密钥对的基类包括公钥和私钥。
RSA.RsaKey.e公钥指数。在 RSA 密钥对中公钥由指数 e 和模数 n 组成。
RSA.RsaKey.n模数。在 RSA 密钥对中模数 n 是一个大整数用于加密和解密操作。
RSA.RsaKey.d私钥指数。在 RSA 密钥对中私钥由指数 d 和模数 n 组成。
RSA.RsaKey.invpp 的模反元素。在 RSA 密钥对中p 是模数 n 的一个素因子。
RSA.RsaKey.invqq 的模反元素。在 RSA 密钥对中q 是模数 n 的另一个素因子。
RSA.RsaKey.qn 的另一个素因子。
RSA.RsaKey.pn 的一个素因子。
RSA.RsaKey.up 的模反元素。
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, e65537)用于生成指定位数的 RSA 密钥对返回RsaKey对象
bits 是密钥的位数
randfunc 是一个随机数生成函数
e 是公钥指数默认为 65537。RSA.import_key(extern_key, passphrase)用于从外部密钥如 PEM 格式的密钥文件中导入 RSA 密钥返回RsaKey对象
extern_key 是一个表示外部密钥的字符串或文件对象
passphrase 是密钥的密码如果有的话。Crypto.PublicKey.DSA提供了 DSA 密钥对的生成、签名和验证功能。
DSA.DsaKey表示 DSA 密钥对包括公钥和私钥。
DSA.DsaKey.public_key()返回公钥对象。该方法返回一个新的 DSA.DsaKey 对象表示 DSA 密钥对的公钥部分。
DSA.DsaKey.export_key(format, pkcs8, passphrase, protection, randfunc)将密钥导出为字符串。该方法可以接受多个参数包括 format导出格式默认为 PEM、pkcs8是否使用 PKCS#8 格式默认为 False、passphrase密钥的密码可选、protection密钥的保护级别默认为 None和 randfunc随机数生成函数可选。
DSA.DsaKey.has_private()检查密钥是否包含私钥。
DSA.DsaKey.can_sign()检查密钥是否可用于签名操作。
DSA.DsaKey.can_encrypt()检查密钥是否可用于加密操作。
DSA.DsaKey.domain()返回 DSA 密钥对的域参数。该方法返回一个字典包含了 DSA 密钥对的参数如 p素数、q素数、g生成元等。DSA.generate(bits, randfunc, domain)用于生成指定位数的 DSA 密钥对返回DsaKey对象
bits 是密钥的位数
randfunc 是一个随机数生成函数
domain 是一个字典包含了 DSA 密钥对的域参数如 p素数、q素数、g生成元等。DSA.import_key(extern_key, passphrase)用于从外部密钥如 PEM 格式的密钥文件中导入 DSA 密钥返回DsaKey对象
extern_key 是一个表示外部密钥的字符串或文件对象
passphrase 是密钥的密码如果有的话。DSA.construct(tup, consistency_check)construct 是一个函数用于根据给定的元组构造 DSA 密钥对返回DsaKey对象
tup 是一个元组包含了 DSA 密钥的组件如 y公钥、x私钥、p素数、q素数、g生成元等
consistency_check 是一个布尔值表示是否进行一致性检查。Crypto.PublicKey.ElGamal提供了 ElGamal 密钥对的生成、加密和解密功能。
ElGamal.ElGamalKey表示 ElGamal密钥对
ElGamal.ElGamalKey.can_sign()用于检查密钥对是否可以用于签名操作。如果密钥对包含私钥则可以进行签名操作该方法将返回 True否则返回 False。
ElGamal.ElGamalKey.can_encrypt()用于检查密钥对是否可以用于加密操作。如果密钥对包含公钥则可以进行加密操作该方法将返回 True否则返回 False。
ElGamal.ElGamalKey.has_private()用于检查密钥对是否包含私钥。如果密钥对包含私钥则返回 True否则返回 False。
ElGamal.ElGamalKey.publickey()用于获取密钥对的公钥部分。它返回一个新的 ElGamal.ElGamalPublicKey 对象其中只包含公钥信息不包含私钥信息。ElGamal.generate(bits, randfunc)用于生成指定位数的 ElGamal 密钥对
bits 是密钥的位数
randfunc 是一个随机数生成函数。ElGamal.construct(tup)用于根据给定的元组构造 ElGamal 密钥对
tup 是一个元组包含了 ElGamal 密钥的组件如 p素数、g生成元、y公钥、x私钥等。Crypto.PublicKey.ECC提供了 ECC 密钥对的生成、加密和解密功能。
ECC.EccKey表示 ECC密钥对
ECC.EccKey.d表示 ECC 密钥对的私钥。
ECC.EccKey.curvec表示 ECC 密钥对所使用的椭圆曲线。
ECC.EccKey.pointQ表示 ECC 密钥对的公钥点。
ECC.EccKey.export_key(formatPEM)用于导出 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, passphraseNone, curve_nameNone)import_key() 函数用于从给定的数据导入一个 ECC 密钥对返回EccKey对象
encoded表示要导入的密钥对的数据可以是一个字节串或字符串。
passphrase可选如果密钥对被密码保护需要提供正确的密码短语才能成功导入密钥对。
curve_name可选指定要使用的椭圆曲线的名称。八、pycryptodome之Crypto.Random
提供了生成随机数的功能。可以使用其中的函数来生成伪随机数和强随机数。
Crypto.Random.random随机数
random.choice(seq)从给定的序列中随机选择一个元素并返回。 sep这可迭代的序列例如列表、元组或字符串然后从中随机选择一个元素并返回random.sample(population, k)从给定的总体中随机选择指定数量的唯一元素并以列表形式返回。 population可迭代的总体作为参数例如列表、元组或字符串然后从中随机选择指定数量的唯一元素并以列表形式返回。
k指定返回数量random.randint(a, b)生成一个指定范围内的随机整数范围包括a和brandom.getrandbits(k)生成一个k位的随机整数并返回random.randrange(start, stop[, step])从指定范围内按指定步长随机选择一个整数并返回 start表示起始值包含
stop表示终止值不包含
step表示步长默认为1andom.shuffle(x)随机打乱可变序列例如列表直接修改原始序列直接修改原始序列
Crypto.Random.get_random_bytes(n)生成一个包含n个随机字节的字节串Crypto.Random.getrandbits(k)生成一个k位的随机整数Crypto.Random.atfork()在多线程环境中使用用于重置随机数生成器的状态。这个函数会在fork子进程之前调用以避免子进程继承父进程的随机数状态。
九、pycryptodome之Crypto.Util
提供了一些常用的工具函数。例如可以使用其中的函数来进行字节串的编码、解码进行填充操作等。
Crypto.Util.Padding提供了填充和去填充数据的函数。
pad(data_to_pad, block_sizet style)用于填充数据 data_to_pad要进行填充的数据类型为字节串bytes。
block_size数据块的长度以字节为单位。填充后的数据长度将是 block_size 的整数倍。
style填充的风格可选值为 pkcs7、iso7816、x923、iso10126、zero 或 None。默认值为 pkcs7。None不进行填充如果数据长度不是块长度的整数倍则会引发 ValueError 异常。unpad(added_data, block_size style)用于去除填充
padded_data已填充的数据类型为字节串bytes。
block_size数据块的长度以字节为单位。
style填充的风格与 pad() 函数中的风格参数相同。默认值为 pkcs7。Crypto.Util.number提供了处理大整数的函数例如生成随机素数、计算模反元素等。
number.inverse(x, m)计算模 m 下 x 的乘法逆元。返回值为 x 在模 m 下的乘法逆元。number.size(x)返回整数 x 的字节大小。number.GCD(a, b)计算整数 a 和 b 的最大公约数Greatest Common DivisorGCD。返回值为 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, randfuncNone)生成一个 N 位的素数。可选参数 randfunc 是一个随机数生成函数用于生成随机数。number.getRandomInteger(N, randfuncNone)生成一个 N 位的随机整数。可选参数 randfunc 是一个随机数生成函数用于生成随机数。number.getRandomNBitInteger(N, randfuncNone)生成一个 N 位的随机整数。可选参数 randfunc 是一个随机数生成函数用于生成随机数。number.getRandomRange(start, stop, randfuncNone)生成一个在范围 [start, stop) 内的随机整数。可选参数 randfunc 是一个随机数生成函数用于生成随机数。number.getStrongPrime(N, e, randfuncNone)生成一个 N 位的强素数其中 e 是公共指数。可选参数 randfunc 是一个随机数生成函数用于生成随机数。number.isPrime(n, k10)检查整数 n 是否为素数。可选参数 k 指定了进行 Miller-Rabin 素性测试的次数。number.long2str(n)将长整数 n 转换为字节串。number.str2long(s)将字节串 s 转换为长整数。
Crypto.Util.py3compat提供了与 Python 2 和 Python 3 兼容性相关的函数和类。
py3compat.bord(x)将字节或字符 x 转换为对应的整数值。在 Python 2 中x 可以是一个字符或字节在 Python 3 中x 必须是一个整数。py3compat.bchr(x)将整数 x 转换为对应的字节或字符。在 Python 2 中返回一个字符在 Python 3 中返回一个字节。py3compat.tobytes(x)将输入 x 转换为字节串。在 Python 2 中x 可以是一个字符串或字节串在 Python 3 中x 必须是一个字符串。py3compat.b(x)将输入 x 转换为字节串。在 Python 2 中返回输入 x 本身在 Python 3 中如果 x 是字符串则返回其对应的字节串。py3compat.BytesIO()创建一个类似于文件对象的字节串缓冲区。在 Python 2 和 Python 3 中都可用。py3compat.bytestring(x)将输入 x 转换为字节串。在 Python 2 中x 可以是一个字符串或字节串在 Python 3 中x 必须是一个字符串。py3compat.is_bytes(x)检查输入 x 是否为字节串。在 Python 2 和 Python 3 中都可用。py3compat.is_native_int(x)检查输入 x 是否为本机整数类型。在 Python 2 和 Python 3 中都可用。py3compat.is_string(x)检查输入 x 是否为字符串类型。在 Python 2 和 Python 3 中都可用。py3compat.StringIO()创建一个类似于文件对象的字符串缓冲区。在 Python 2 和 Python 3 中都可用。py3compat.tostr(x)将输入 x 转换为字符串。在 Python 2 中x 可以是一个字符串或字节串在 Python 3 中x 必须是一个字符串。
十、pycryptodome之Crypto.Protocol
提供了一些密码学协议的实现。例如可以使用其中的类来进行密钥交换、安全通信等。
Crypto.Protocol.SecretSharing秘密共享通过将秘密分割成多个部分份额可以将其分发给不同的参与者。只有在达到指定的阈值份额时才能恢复原始的秘密。这对于实现安全的多方协议和数据保护非常有用。
SecretSharing.Shamir.split(k,n,secret,ssss)分割秘密
k一个整数表示恢复秘密所需的最小份额数。
n一个整数表示生成的总份额数。
secret一个字节串表示要分割的原始秘密16字节。
ssss一个整数表示生成份额时使用的随机数种子SecretSharing.Shamir.combine(shares,ssss)恢复秘密 shares一个包含份额的列表。
ssss一个整数表示生成份额时使用的随机数种子。from Crypto.Protocol.SecretSharing import Shamirk 3 # 恢复秘密所需的最小份额数
n 5 # 生成的总份额数
secret bHello,Word!!!!!! # 要分割的原始秘密shares Shamir.split(k, n, secret) #分割秘密
print(生成的份额, shares)recovered_secret Shamir.combine(shares[:k]) # 组合份额恢复秘密
print(恢复的秘密, recovered_secret)Crypto.Protocol.KDF密钥派生密钥派生函数可以从一个输入密钥派生出更长或更复杂的密钥以供加密、认证或其他密码学操作使用。
KDF.HKDF(master, key_len, salts, hashmod, num_keys, context)基于 HMAC 的密钥派生函数HKDF的实现。它使用输入的主密钥master和其他可选参数来派生一个或多个密钥返回一个包含派生密钥的列表。
master一个字节串作为主密钥。
key_len一个整数表示派生密钥的长度。
salts一个字节串或一个列表用于指定盐值。如果提供了多个盐值则会使用每个盐值进行密钥派生并将结果连接在一起。
hashmod一个哈希模块例如 Crypto.Hash.SHA256。
num_keys一个整数表示要派生的密钥个数。
context一个字节串用于提供上下文信息。KDF.scrypt(password, salt, key_len, N, r, p, num_keys)基于密码派生函数的实现。它使用密码和盐值作为输入并使用一组参数来派生一个或多个密钥返回一个包含派生密钥的列表。
password一个字节串作为密码。
salt一个字节串作为盐值。
key_len一个整数表示派生密钥的长度。
N一个整数表示 scrypt 的 CPU/内存成本因子。
r一个整数表示 scrypt 的块大小。
p一个整数表示 scrypt 的并行化因子。
num_keys一个整数表示要派生的密钥个数。KDF.bcrypt(password, cost, salt)bcrypt 密码哈希函数的实现。它使用密码和盐值作为输入并使用指定的计算成本cost来计算哈希值返回一个包含 bcrypt 哈希值的字节串
password一个字节串作为密码。
cost一个整数表示计算成本即计算哈希值所需的时间和资源。
salt一个字节串作为盐值。KDF.bcrypt_check(password, bcrypt_hash)验证 bcrypt 哈希值的函数。它使用密码和存储的 bcrypt 哈希值作为输入并返回一个布尔值指示密码是否匹配存储的哈希值返回一个布尔值指示密码是否匹配存储的哈希值。
password一个字节串作为密码。
bcrypt_hash一个字节串作为存储的 bcrypt 哈希值。KDF.PBKDF1(password, salt, dkLen, count, hashAlgo)PBKDF1 密码基于密码派生函数的实现。它使用密码和盐值作为输入并使用指定的哈希算法和迭代次数来派生密钥返回一个包含派生密钥的字节串。
password一个字节串作为密码。
salt一个字节串作为盐值。
dkLen一个整数表示派生密钥的长度。
count一个整数表示迭代次数。
hashAlgo一个哈希算法模块例如 Crypto.Hash.SHA256。KDF.PBKDF2(password, salt, dkLen, count, prf, hmac_hash_module)BKDF2 密码基于密码派生函数的实现。它使用密码和盐值作为输入并使用指定的伪随机函数PRF和迭代次数来派生密钥返回一个包含派生密钥的字节串。
password一个字节串作为密码。
salt一个字节串作为盐值。
dkLen一个整数表示派生密钥的长度。
count一个整数表示迭代次数。
prf一个 PRF 对象例如 Crypto.Protocol.KDF.PRF。
hmac_hash_module一个哈希算法模块例如 Crypto.Hash.SHA256。KDF.SP800_108_Counter(master, key_len, prf, num_keys, label, context)使用 SP800-108 密钥派生函数派生密钥 master主密钥。
master主密钥。
key_len派生密钥的长度以字节为单位。
prf伪随机函数。
num_keys要派生的密钥数量。
label标签。
context上下文数据可选参数。十一、pycryptodome之Crypto.Math
提供了一些密码学相关的数学函数和算法的实现。例如可以使用其中的类来进行大数运算、素数生成和验证等。
Crypto.Math.Primality素数相关数学函数
generate_probable_prime(exact_bits, randfunc, prime_filter)用于生成一个指定位数的可能素数
exact_bits生成素数的位数。
randfunc一个随机数生成函数用于生成随机数。
prime_filter一个可选的函数用于过滤掉不符合特定条件的候选素数。generate_probable_safe_prime(exact_bits, randfunc)用于生成一个指定位数的可能安全素数
exact_bits生成素数的位数。
randfunc一个随机数生成函数用于生成随机数。Crypto.Math.Numbers数字相关数学函数
numbers Numbers.Integer(2)创建Numbers对象numbers.ize_in_bytes()返回整数的字节大小。numbers.size_in_bits()返回整数的位数。numbers.set(source)将整数设置为给定的值。numbers.random(**kwargs)生成一个随机的整数。numbers.random_range(**kwargs)生成一个指定范围内的随机整数。numbers.sqrt(modulus)计算整数的平方根模 modulus。numbers.lcm(term)计算整数与给定项 term 的最小公倍数。numbers.gcd(term)计算整数与给定项 term 的最大公约数。numbers.fail_if_divisible_by(small_prime)如果整数可以被给定的小质数 small_prime 整除则引发异常。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()检查整数是否为完全平方数。
