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

pip install pycryptodome

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

from Crypto.Hash import SHAKE128

data = b'hello word'

shake128 = SHAKE128.new(data)

shake128.update(b'hello')

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

from Crypto.Hash import SHAKE256

data = b'hello word'

shake256 = SHAKE256.new(data)

shake256.update(b'hello')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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