PyCryptodome模块实现多种加密算法

爱思考的实践者

已于 2024-01-19 15:32:20 修改

阅读量2.2k

点赞数 3

文章标签： python 密码学

于 2021-04-02 15:21:13 首次发布

本文链接：https://blog.csdn.net/chinawangfei/article/details/115377773

版权

一、PyCryptodome说明

PyCryptodome是python一个强大的加密算法库，可以实现常见的单向加密、对称加密、非对称加密、非对称加密算法签名和流加密算法。
直接pip安装即可：pip install pycryptodome
官网地址：https://pypi.org/project/pycryptodome/

二、base64编码

2.1 base64编码说明

原理：将要编码的内容按3字节为一组进行分组，最后一组不够3位的则补0（显然最多补两个0）。

编码步骤：
第一步：每组中每字节最高2位改成0不使用，原先各位的内容保持原有顺序往后移；

第二步：在上一步中补了几个0，就加几个等号，以供解码时按等号个数删除0（经此操作，原先3节字就变成了只使用低6位的4字节）。

转换前 10101101,10111010,01110110
转换后 00101011, 00011011 ,00101001 ,00110110
用途：

（1）SMTP中要以BASE64格式传输二进制文件。

（2）将二进制数据转成可打印的ASCII码字符进行存储（下文各加密算法的密钥一般使用十六进制字符串形式存储，但也有以base64形式存储）。
本质上讲，Base64只能算是一种编码，不能算是一种加密算法，PyCryptodome库也不支持。但是，从”Base64让人一下看不懂原本内容是什么“的角度讲，也不能说他完全不算加密，平时也经常用，我们就顺道讲一讲如何实现。

2.2 base64编码使用示例

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import hashlib
import base64


# 对bytes类型进行再次编码(先将字符串转换为bytes)
def base_info():
    str = '我喜欢 computer'
    # e = base64.b64encode(b"123456")       # 结果：b'MTIzNDU2'
    e = base64.b64encode(str.encode())  # 结果：b'5oiR5Zac5qyiIGNvbXB1dGVy'
    print("编码过程：", e)
    d = base64.b64decode(b'5oiR5Zac5qyiIGNvbXB1dGVy')
    print("解码过程：", d.decode())


if __name__ == '__main__':
    base_info()

运行结果为：

编码过程： b'5oiR5Zac5qyiIGNvbXB1dGVy'
解码过程： 我喜欢 computer

三、单向加密算法

3.1 单向加密算法说明

别称：单向加密算法，又称哈希函数、散列函数、杂凑函数、摘要算法，英文名One-way encryption algorithm。
原理：单向加密如其名，只能加密、不能解密（彩虹表攻击不是正经的解密）。不能解密的原因是：本质上并不是用IV（Initial Vector）去加密M输出M对应的密文，而是用M去加密IV输出IV对应的密文。
用途：消息认证摘要、内容或文档的数字指纹、口令存储。
单向加密可以分为hash和hmac两大类，hmac和hash的算法是一样的，可以认为hmac就是hash加盐的形式（这盐值不是hash中常用的拼接在最前边，或拼接在最后边，而是以某种规则处理）。
一般来说，标准库就挺好用，我们一般就直接使用标准库。python的标准库能容易地实现单向加密算法，所以我们使用标准库实现单向加密。
python中，hash类算法使用hashlib库实现，hmac类算法使用hmac库实现。

3.2 标准库支持的单向加密算法

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import hashlib

if __name__ == '__main__':
    print(hashlib.algorithms_available)  # 支持的单向加密算法

运行结果为：

{'SHA', 'md5', 'MD4', 'sha512', 'blake2b', 'blake2s', 'MD5', 'SHA1', 'SHA224', 'dsaWithSHA', 'SHA512', 'DSA-SHA', 'sha3_384', 'md4', 'shake_128', 'sha', 'sha3_512', 'whirlpool', 'dsaEncryption', 'sha384', 'sha3_224', 'SHA384', 'SHA256', 'DSA', 'sha256', 'sha3_256', 'ecdsa-with-SHA1', 'sha1', 'sha224', 'RIPEMD160', 'shake_256', 'ripemd160'}

注意：输出结果中，各算法使用大写和小写写了两遍，也就是说，算法名大写或小写都是可以的。

3.3 使用hashlib实现hash算法（以md5为例）

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import hashlib
from Crypto.Hash import MD5

if __name__ == '__main__':
    encode = 'utf-8'  # 编码
    message = 'md5test.'  # 待加密信息

    # 第1种写法
    hl = hashlib.md5()  # 创建md5对象
    hl.update(message.encode(encoding=encode))  # 转换为bytes
    token1 = hl.hexdigest().upper()  # hexdigest() 加密过程：以十六进制字符串形式输出
    print('第1种MD5加密后为 ：' + token1)

    # 第2种写法
    hl = hashlib.new("md5")
    hl.update(message.encode(encoding=encode))  # 转换为bytes
    token2 = hl.hexdigest().upper()  # hexdigest() 加密过程：以十六进制字符串形式输出
    print('第2种MD5加密后为 ：' + token2)

    # 第3种写法：b前缀代表的就是bytes
    token3 = hashlib.md5(b'md5test.').hexdigest().upper()
    print('第3种MD5加密后为 ：' + token3)

    # 第4种写法：b前缀代表的就是bytes
    token4 = MD5.new(b'md5test.').hexdigest().upper()
    print('第4种MD5加密后为 ：' + token4)
    print(token1 == token4)
    print(token2 == token4)
    print(token3 == token4)

运行结果为：

第1种MD5加密后为 ：78E460968622DB56F5D08AAA6C523FAE
第2种MD5加密后为 ：78E460968622DB56F5D08AAA6C523FAE
第3种MD5加密后为 ：78E460968622DB56F5D08AAA6C523FAE
第4种MD5加密后为 ：78E460968622DB56F5D08AAA6C523FAE
True
True
True

3.4 使用hmac实现hmac算法（以sha1为例）

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import hmac

if __name__ == '__main__':
    # 实例化原形是 hmac.new(key, msg=None, digestmod=None)
    # key--加密用的盐值
    # msg--要加密码的内容，可为空而后用update方法设置
    # digestmod--加密算法，默认为md5(所有支持的算法名参考hashlib.algorithms_available)
    key = b"a1b2c3d"
    m = hmac.new(key, digestmod="sha1")
    # update使用+=，即连续多次update表示"在原先内容上追加而不是替换"
    # 要注意: 所谓的+=是msg之间的+=，而不是key和msg之间的+=
    # 即使用以下update后，等于hmac.new(b"123",b"123456", digestmod="sha1")，但不等于hmac.new(b"123123456", digestmod="sha1")
    m.update(b"123456")
    # 以十六进制字符串形式输出
    print(m.hexdigest())

运行结果为：

a29aa8c65676407680b407a4c972f3fe6865de6a

四、对称加密算法

4.1 对称加密算法说明

别名：对称加密算法，又称密钥加密算法、单密钥算法、共享密钥算法，英文名Symmetric Encryption Algorithms。œ
原理：对称加密算法最关键的就是SP变换，S变换通过代替操作实现混乱（即消除统计信息），P变换通过换位操作实现扩散（即雪崩效应）。加解密是使用同一个密钥的逆操作过程。
用途：对称加密可以还原内容，代替和换位操作运算量不大，适用于大量内容的加解密。对称加密算法的缺点是：加解密双方密钥分发困难。
对称加密算法有ECB、CBC、CFB、OFB、CTR等多种模式。各种模式的加密是有些区别的，比如ECB不需要IV、CBC等则需要IV、EAX则需要nonce和tag等等。所以，实现不同模式时，写法会有差别，需要具体研究，不能完全照搬下边的例子。

4.2 对称加解密算法实现代码（以AES算法CBC模式为例）

4.2.1 对称加密算法实现

#!/usr/bin/python3
# -*- coding: utf-8 -*-

from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad

if __name__ == '__main__':
    # 要加密的内容
    data = "123456"
    # 随机生成16字节（即128位）的加密密钥
    key = get_random_bytes(16)
    # 随机生成16字节（128）的iv
    iv = get_random_bytes(16)
    encoding = 'utf-8'  # 编码
    # 实例化加密套件，使用CBC模式
    cipher = AES.new(key, AES.MODE_CBC, iv)
    # 对内容进行加密，pad函数用于分组和填充
    encrypted_data = cipher.encrypt(pad(data.encode(encoding), AES.block_size))
    print("key=" + str(key))
    print("cipher.iv=" + str(cipher.iv))
    print("encrypted_data=" + str(encrypted_data))

    # 将加密内容写入文件
    file_out = open("encrypted.bin", "wb")
    # 在文件中依次写入key、iv和密文encrypted_data
    [file_out.write(x) for x in (key, cipher.iv, encrypted_data)]

运行结果如下：

key=b'\xd9he*J\x94~\x81\x8c\xdd\xd4P\xac\xeb\xbb['
cipher.iv=b'\xfc\xf2\xbd2qp\x07s\xdf\xa4\xe3c\xc2J\x0f\x06'
encrypted_data=b'\xdd\xd2!\xa9\x041>\xd1\x85ab\xd4<\x1e%c'

4.2.2 对称解密算法实现

#!/usr/bin/python3
# -*- coding: utf-8 -*-

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

if __name__ == '__main__':
    # 从前边文件中读取出加密的内容
    file_in = open("encrypted.bin", "rb")
    # 依次读取key、iv和密文encrypted_data。16是key变量的长度，16为iv变量的长度，最后的-1则表示读取到文件末尾。
    key, iv, encrypted_data = [file_in.read(x) for x in (16, 16, -1)]

    # 实例化加密套件
    cipher = AES.new(key, AES.MODE_CBC, iv)
    # 解密，如无意外data值为最先加密的b"123456"
    data = unpad(cipher.decrypt(encrypted_data), AES.block_size)
    encoding = 'utf-8'  # 编码
    print("key=" + str(key))
    print("cipher.iv=" + str(cipher.iv))
    print("encrypted_data=" + str(encrypted_data))
    print("data=" + str(data.decode(encoding=encoding)))

运行结果如下所示：

key=b'\xd9he*J\x94~\x81\x8c\xdd\xd4P\xac\xeb\xbb['
cipher.iv=b'\xfc\xf2\xbd2qp\x07s\xdf\xa4\xe3c\xc2J\x0f\x06'
encrypted_data=b'\xdd\xd2!\xa9\x041>\xd1\x85ab\xd4<\x1e%c'
data=123456

五、非对称加密算法

5.1 非对称加密算法说明

别称：非对称加密算法，又称公钥加密算法，英文名Asymmetric Cryptographic Algorithm。

原理：非对称加密依赖与明文经过与公钥进行数学运算，可得出密文；而密文经过与密钥进行数学运算，又可得到明文。

用途：非对称加密算法的优点是密钥分发简单，但缺点也是很明显的，其加解密过程依赖于数学运算，运算量大，所以加解密速度慢（另外，同样的密钥强度，其安全性弱于对称加密算法），其只适用于少量内容的加解密，最典型的场景就是https中用于完成对称密钥的交换。

5.2 非对称加密算法实现代码（以RSA为例）

5.2.1 生成公私密钥对

#!/usr/bin/python3
# -*- coding: utf-8 -*-

from Crypto.PublicKey import RSA

if __name__ == '__main__':
    # 生成密钥对
    key = RSA.generate(2048)

    # 提取私钥，并存入文件
    private_key = key.export_key()
    file_out = open("private_key.pem", "wb")
    file_out.write(private_key)
    print("private_key=" + (str(private_key)))
    print("private_key len=" + str(len(str(private_key))))

    # 提取公钥，并存入文件
    public_key = key.publickey().export_key()
    file_out = open("public_key.pem", "wb")
    file_out.write(public_key)
    print("public_key=" + str(public_key))
    print("public_key len=" + str(len(str(public_key))))

运行结果为：

private_key=b'-----BEGIN RSA PRIVATE KEY-----\nMIIEogIBAAKCAQEAodE8bqIa7nbdqH10R5vxY2BfEJBAdM7heenOYJ+oyOPETpSe\nE7EdpCGTwFG3KJsEFrc0HOzKOU+jltzp7U6prTaNQPH+viqN3whjvPek+K00yUY0\npOySMOx+pUVrVeq/ML7jpn6wl29R0I1ewuNXqgFnSefVBlfDRuMv4mDnIMuAY5Jp\n33R6uWgGYr66XRFsvCITdx/qEBgh7kJ580aEKiJ96GZe53RrI/uoi1ttU7bwDgB3\njUWG28DmVWM4DPsJ5pxv5R0F3o6ueQUgQ2DoYGzrS7A28wuclp8I5EexcMxlb2mP\nll9so3SySfpddHCRfCD0/C88DN+DYl5FLqbT6wIDAQABAoIBADA/V0HzYo1Mcr28\nnjGFvRzwzJd/M0DAuHjlrgugPy6avtrhNBrR+fEIs+mpU6+vPLJbMJYZQhiBdtjS\nCIuhozTKqaY+IULpJEDmWvqqag1dc3o5zROJl/MvaHl1r9G/uv7ZQ75OUu/sGJxS\nsnjwWSCO55GhJqKMA2T88zePxgpAOT4zEoNSnp7/Keq0AutQxZrQuFaSQ2iRjq75\nholLAZdfFnVvXJa5TBevjfEouBsTuIWd70LY6sXGvG+PfOeJub/RIZz3yajv3oFV\nJYcHGWA54CC4k8QLWEYwKPx4LC2iXHQqFIsI8qPCSC5y2+tS/CV1izSN3ot0AU9f\nDzH8be0CgYEAu0TVsqn33XZGv9pEQbS7TFfxqXWi+E8i6kVGPUha/6UDVQVKJ6kL\nyjfgjI04ysYu7i2bK1Faf1/xFcJYn8pa6oHwBek8e5ua/FS/is/DwiDzP66k7vsp\nnro0C/KuTpChqVcym45A8xQ9UPlBiGyrTjrG/Jv2Lkx9WHqZiLY8l58CgYEA3TUO\noHk5RqMNPsdxVpw/jfeJzoT2NsdORlHXXuIe16JjEinF1YW4Cu3hEE91JetRKKGk\nepueV0rYwN5zo5XyNAHSTZEIgnGftMW4TfNd1xFc72xF3nOHTWjp8pDpZ7m9vxTO\n1kBrskVcSVMKVCCUG7Dlur9cf0YhgRJ8avfukDUCgYB6XKHdWd3RYOUdmrqazELN\nwXDwLyNLaDoCJT2d8Vc0T1f8B7bKb1R6z0Pz0prXM+OaUUZgaYneTIw0kYZi8k+x\nhzGUSy/v/F6qnZ2CT/szL2CBrdWrKYWqZzR20h0+zJY1FfrFVY/uxLzD2foN8COG\nvDUk/as/2U7Vr1X+1ESHNQKBgDaSaFFelqq+fv4F5ggf8+3qK60vUC6jbMQcXK2j\ny0gXX6mTdKMAoi7QEL4dXCFGtHb5qcI1shKG/IJYXt70lxQNfvxz002bCnNmc9mH\nOJdeSTcn1vTSO4b1YwHcjjhwskb5sy1YJzmLswDD48BtaRyLv6EapI8hlhJppRge\nolQhAoGAI0TQPyU4umlzsS4abpx/K9CC3GqMoF4yZ7vau8FA4/5vZfoX75ippKgt\n6ra7oM9SVSBaM4FOmKzzDXZQkH8DXaR3/Yn+e0oB8ed8ud+iV9rZx4ImIQ/QFlU6\nwQqwYZwd65Qp6aOIUYosQcBE4yU8/oIxKILbIo+Ef8+/NoR7rdo=\n-----END RSA PRIVATE KEY-----'
private_key len=1703
public_key=b'-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAodE8bqIa7nbdqH10R5vx\nY2BfEJBAdM7heenOYJ+oyOPETpSeE7EdpCGTwFG3KJsEFrc0HOzKOU+jltzp7U6p\nrTaNQPH+viqN3whjvPek+K00yUY0pOySMOx+pUVrVeq/ML7jpn6wl29R0I1ewuNX\nqgFnSefVBlfDRuMv4mDnIMuAY5Jp33R6uWgGYr66XRFsvCITdx/qEBgh7kJ580aE\nKiJ96GZe53RrI/uoi1ttU7bwDgB3jUWG28DmVWM4DPsJ5pxv5R0F3o6ueQUgQ2Do\nYGzrS7A28wuclp8I5EexcMxlb2mPll9so3SySfpddHCRfCD0/C88DN+DYl5FLqbT\n6wIDAQAB\n-----END PUBLIC KEY-----'
public_key len=461

5.2.2 公私加密

#!/usr/bin/python3
# -*- coding: utf-8 -*-

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP

if __name__ == '__main__':
    # 要加密的内容
    data = b"123456"
    # 从文件中读取公钥
    public_key = RSA.import_key(open("public_key.pem").read())
    # 实例化加密套件
    cipher = PKCS1_OAEP.new(public_key)
    # 加密
    encrypted_data = cipher.encrypt(data)

    # 将加密后的内容写入到文件
    file_out = open("encrypted_data.bin", "wb")
    file_out.write(encrypted_data)
    print("origin data=" + str(data))
    print("encrypted_data=" + str(encrypted_data))

运行结果为：

origin data=b'123456'
encrypted_data=b"u\x92\x95\xbe\xeb\x9e}C$\x88\x05\xa6\xaf\xf3T\xef\x8dF'&\xb4Z\xb5\xae}\xd9\x85a\x96\x92\\\x17z\xf0_n\x01\xff\xeb\xc0\xc1\xb9\x96\x10\x7f\xff\x1aI~o\xc5\xaf\xf1\xab\xd2\x80\xa4\x98\x8b\x7f\xcaK`>\xd3%\xf0\xda\x8b\xbdB\x83\xee\xd4\x0cE\xecM\xb7X\xddy\x0f3&\xe2\x02\x94\x03\x864>\xab\xef'\xd9\xf38\x8c\x8f\xa8\xe2\r(\xbd\xc2n\xe3n\xc9%\xa5D\xd5~3\xff\x83J\xb8w\x8e\xaa\x07\x11\x12\xb0\\\x1a\xbdr\xd7_\xa7\xee\xbc\x8b-\x9e\xc2\xea\xec\xc0\xa0B\x1b\xb5\x8f,T\x12/\xde5\x1c\x19\xcb\xe4ml\x7fV\xdc\xc2\xf4\x99\x17\x9du\xc1\x95\x8d8\xd2\x07\x06\xc1\x9e6\xd9\x93\x91\xceI `\x0e\xa1_\xe3\xae\xb6\x91\xdc\xa4\xea\x040SQA\xf3\x85\x86\xfa\xe0\x9d\x8e\xf0^\x80*\x1b\xd6n\x07\xf1b.0\x90\xd4\xd0\x9cu\xae\x07\xf2\xf1X\xfe\x8c\x18\x11\x96\xca\xe0\x91\x8aCR\x86/\xe4\xe2\xfb\xb2\xea\x9ep\x9a\x18\x95\xc2;\xf4"

5.2.3 私钥解密

#!/usr/bin/python3
# -*- coding: utf-8 -*-

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP

if __name__ == '__main__':
    # 从私钥文件中读取私钥
    private_key = RSA.import_key(open("private_key.pem", "rb").read())
    # 实例化解密套件
    cipher = PKCS1_OAEP.new(private_key)
    # 从文件中读取加密内容
    encrypted_data = open("encrypted_data.bin", "rb").read()
    # 解密
    data = cipher.decrypt(encrypted_data)
    print("data=" + str(data))

运行结果为：

decrypted_data=b'123456'

5.3 非对称加密算法实现签名（以RSA为例）

在实际应用场景中，私钥不能加密，只能做签名。

签名步骤为：

1.用摘要算法计算出原始内容的指纹值；

2.获取私钥；

3.用私钥对计算出的指纹值进行签名。

签名校验步骤为：

1.用摘要算法计算出原始内容的指纹值；

2.获取公钥；

3.用公钥解密签名值，判断解密出来的值是否与指纹值相等。

#!/usr/bin/python3
# -*- coding: utf-8 -*-

from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256
from Crypto.PublicKey import RSA

if __name__ == '__main__':
    # 以下是签名部分
    # 要签名的内容
    data = b'123456'
    # 获取要签名的内容的指纹值。摘要算法是什么不重要，只要验证时使用一样的摘要算法即可。
    digest = SHA256.new(data)
    # 读取私钥
    private_key = RSA.import_key(open('private_key.pem').read())
    # 对指纹值使用私钥进行签名。所谓签名，本质就是使用私钥对指纹值进行加密。
    signature = pkcs1_15.new(private_key).sign(digest)

    # 以下是签名校验部分
    # 要传给签名校验部分三个信息：签名内容原文、摘要算法、HASH值签名结果
    # 获取被签名的内容的指纹值。使用与签名部分一样的摘要算法计算。
    digest = SHA256.new(data)
    # 读取公钥
    public_key = RSA.import_key(open('public_key.pem').read())

    try:
        # 进行签名校验。本质上就是：使用公钥解密signature，判断解密出来的值是否与digest相等。
        # 若相等，则校验通过，说明data是原先的内容；否则，说明data或signature被篡改。
        # 可能有人会想：如果先修改data，然后再用自己的私钥算出signature，是不是可以完成欺骗？
        # 答案是不能，因为此时使用原先的公钥去解signature，其结果不会等于digest。
        pkcs1_15.new(public_key).verify(digest, signature)
        print("The signature is valid.")
    except (ValueError, TypeError):
        print("The signature is not valid.")

运行结果为：

The signature is valid.

六、流加密算法实现（以RC4为例）

6.1 流加密算法说明

别称：流加密算法，又称序列加密算法，英文名Stream cipher。

原理：流加密算法的加密和解密使用同一个密钥。咬文嚼字来说，它也属于对称加密算法。

流加密算法与单向加密算法、对称加密算法、非对称加密算法的区别是：前三者都是分组加密算法（即一个分组使用同一个密钥），而流加密算法每一位都使用不同的密钥。

用途：流加密主要基于异或（xor）操作，运算相对简单，但安全性较低，没有很多的使用场景。最典型的是WEP上的使用，但也正由于其安全性问题，导致WEP的淘汰。

6.2 流加密算法实现代码（以RC4为例）

#!/usr/bin/python3
# -*- coding: utf-8 -*-

from Crypto.Cipher import ARC4
from Crypto.Random import get_random_bytes

if __name__ == '__main__':
    # 要加密的内容
    data = b"123456"
    # 流加密密码长度是可变的，RC4为40到2048位。
    # 一般使用一个字符串作为初始密钥，然后再用sha1等生成真正的密钥。
    # 方便起见，这里直接使用随机生成的16字节（即128位）作为密钥。
    key = get_random_bytes(16)
    # 实例化加密套件
    cipher = ARC4.new(key)
    # 加密内容
    encrypted_data = cipher.encrypt(data)

    # 注意在即便加解密像这里一样在同一文件里，解密时一定要重新实例化不然解密不正确
    cipher = ARC4.new(key)
    # 解密，如无意外data为前边加密的b"123456"
    decrypted_data = cipher.decrypt(encrypted_data)

    print("origin_data=" + str(data))
    print("encrypted_data=" + str(encrypted_data))
    print("decrypted_data=" + str(decrypted_data))

运行结果为：

origin_data=b'123456'
encrypted_data=b'hL)\xa1\xb7\xe5'
decrypted_data=b'123456'

参考：

Examples — PyCryptodome 3.19.1 documentation

https://github.com/nemozqqz/pycrypto-sample/blob/master/RC4.py

爱思考的实践者

关注

3
点赞
踩
12

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫