Python之RSA加密 解密 签名 验证

Python之RSA加密 解密 签名 验证

1、前言

Pycrypto提供了比较完善的加密算法。RSA广泛用于加密与解密，还有数字签名通信领域。使用Publick/Private秘钥算法中，加密主要用对方的公钥，解密用自己的私钥。签名用自己的私钥，验签用对方的公钥。

• 加密解密：公钥加密，私钥解密
• 签名验签：私钥签名，公钥验签

无论是加密解密还是签名验签都使用同一对秘钥对

windows安装

pip install pycryptodome

2、RSA算法简介：

RSA加密算法是一种非对称加密算法，加密的秘钥是由公钥和私钥两部分组成秘钥对，公钥用来加密消息，私钥用来对消息进行解密，公钥是公开的，私钥则是用户自己保留的，由于公钥是公开的，那么任何人只要获取到公钥，都可以使用公钥来加密发送伪造内容，出于安全性考虑，在发送消息之前我们可以使用RSA来签名，签名使用私钥来进行签名，使用公钥来进行验签，通过签名我们可以确保用户身份的唯一性，从而提高安全性。

2.1、加密和签名的区别

• 加密：比方现在有两个人A和B，A要给B传递机密的信息，为了避免信息泄露，B事先通过RSA加密算法生成了一对秘钥，并且将公钥事先给到A，私钥则自己保留，A给B传递消息的时候，先使用B给的公钥对消息进行加密，然后再将消息传递给B，B拿到加密后的消息，可以通过私钥对消息进行解密，消息在传递过程中就算被他人获取了也没关系，没有私钥就没办法对消息进行解密。但是这个时候还有一个问题，公钥一般都是公开的，会同时给到多个人，那么如果这个时候还有一个人C，获取到了这个公钥，他通过公钥对消息进行加密，想冒充A来给B发信息，那么B接受到信息之后，能够通过私钥来对消息进行解密，但是无法确认这个信息到底是不是A发的（有可能是别拿的公钥加密发的），为了区分发送者的身份，那么这个时候我们就要用到签名。

• 签名：虽然我们通过加密能够确保发送的消息不被泄密，但是却无法区分发送者的身份，A用户为了区分自己的身份，同样也生成了一对秘钥，事先将公钥给到B，发送消息的时候，先用B给的公钥对消息进行加密，然后用A自己的私钥生成签名，最后将加密的消息和签名一起发过去给B，B接收到A发送的数据之后，首先使用A用户的公钥对签名信息进行验签，确认身份信息，如果确认是A用户，然后再使用自己的私钥对加密消息进行解密。

• A的一组消息通过加密和签名处理之后，再发送出去给B，就算被人截获了，也没有关系，没有B的私钥无法对消息进行解密，就算获取A的公钥，想要发送伪造信息，没有A私钥也无法进行签名。同样B给A回复消息的时候，可以通过B的公钥进行加密，然后使用自己的私钥生成签名，A接收到数据化使用同样的方式进行解密验证身份。 这样一来就能够做到万无一失。

3、python实现RSA加解密和签名加解签

接下来我们就来使用python来实现RSA加密与签名，使用的第三方库是Crypto具体实现的代码如下：

3.1、生成秘钥对

在这边为了方面演示，手动生成一个密钥对（项目中的秘钥对由开发来生成，会直接给到我们）

生成秘钥对的时候，可以指定生成秘钥的长度，一般推荐使用1024bit, 1024bit的rsa公钥，加密数据时，最多只能加密117byte的数据），数据量超过这个数，则需要对数据进行分段加密，但是目前1024bit长度的秘钥已经被证明了不够安全，尽量使用2048bit长度的秘钥。2048bit长度的秘钥，最多245byte长度的数据

计算公式如下：

秘钥长度最大加密量（单位：）

下面生成一对1024bit的秘钥

def create_rsa_key(self):
    
    """
    创建RSA密钥
    步骤说明：
    1、从 Crypto.PublicKey 包中导入 RSA，创建一个密码
    2、生成 1024/2048 位的 RSA 密钥
    3、调用 RSA 密钥实例的 exportKey 方法，传入密码、使用的 PKCS 标准以及加密方案这三个参数。
    4、将私钥写入磁盘的文件。
    5、使用方法链调用 publickey 和 exportKey 方法生成公钥，写入磁盘上的文件。
    """
    
    # 伪随机数生成器6
    random_gen = Random.new().read
    # 生成秘钥对实例对象：1024是秘钥的长度
    rsa = RSA.generate(1024, random_gen)

    # Server的秘钥对的生成
    private_pem = rsa.exportKey()
    with open("server_private.pem", "wb") as f:
        f.write(private_pem)

    public_pem = rsa.publickey().exportKey()
    with open("server_public.pem", "wb") as f:
        f.write(public_pem)

    # Client的秘钥对的生成
    private_pem = rsa.exportKey()
    with open("client_private.pem", "wb") as f:
        f.write(private_pem)

    public_pem = rsa.publickey().exportKey()
    with open("client_public.pem", "wb") as f:
        f.write(public_pem)

私钥格式

-----BEGIN RSA PRIVATE KEY-----
MIICWwIBAAKBgQCEXMMVpgVXcL5ulBMIgwv0z/osfA1bXJSPxmKjoq11CVTTu4qE
JJo6/rgXro44rw/gy/WHLgnK+UQqs5l7aNIghAX8AL8beRf5DAIWtWiEFPGLJDFR
HTEK52iwyvcBqeI5gL1Z+Vxo1k3pMY6zjABWNBwQ7OR152ge1JKkjTPBrQIDAQAB
AoGAG13Kf/lZdWC8HsTCwqnFmRI/GV90q4USuj88ObTyxBXv0e8ejn+626O6kDro
8NNRJxtEYnSkVbD/5QxJGXjsqLxEszrRP2XP1lX/56+8VfSbwB2ywFjssgcIJcur
5iYi01aBNrCU6uYYsWcLCtDhJ+VRBvRTusBMSxPgDTTrHQECQQC3bH7dyB2KF2dV
Z2GjmchqGYJ/2Zw/pfwcKwa84gROO84rGCwTayVmYhDcjx4UzAlFJ16b239KeQO7
299JW0kNAkEAuLwcOYOW6LTX4ot8SLXM15aJdvuotFY3Codx1ThJAT9jCMczru73
4kT0L25C+vbr4937aCWpCbM6E+58BHjzIQJAPXERejcrdfNrANe1hDjiQnAzH6KE
TWnLbqAXDLRlHtO3twXM1eBhUc9tuIQUXoEOZeTPM0QueoLY9lerjwYODQJAFpey
3/nO5/DOAj/K2F2birY3Y5zNehidLKV573itvQBSjU1Hbdp96GdEcdSLToQKP1jz
mT4Z2TzZGnztH+Lm4QJAQjaQCNq9K4drlxwSDmdGmYUQOIUiwcImQdfukYXtIWYb
VqDmmC1ehXC02v4peUlWGyQwxhrB/CbkD5VW3vLU/w==
-----END RSA PRIVATE KEY-----

公钥格式

-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCEXMMVpgVXcL5ulBMIgwv0z/os
fA1bXJSPxmKjoq11CVTTu4qEJJo6/rgXro44rw/gy/WHLgnK+UQqs5l7aNIghAX8
AL8beRf5DAIWtWiEFPGLJDFRHTEK52iwyvcBqeI5gL1Z+Vxo1k3pMY6zjABWNBwQ
7OR152ge1JKkjTPBrQIDAQAB
-----END PUBLIC KEY-----

3.2、公钥加密

# Server使用Client的公钥对内容进行rsa 加密
    def encrypt(self, plaintext):
        """
        client 公钥进行加密
        plaintext:需要加密的明文文本，公钥加密，私钥解密
        """

        # 加载公钥
        rsa_key = RSA.import_key(open("client_public.pem").read() )

        # 加密
        cipher_rsa = Cipher_PKC.new(rsa_key)
        en_data = cipher_rsa.encrypt(plaintext.encode("utf-8")) # 加密

        # base64 进行编码
        base64_text = base64.b64encode(en_data)
 
        return base64_text.decode() # 返回字符串

3.3、私钥解密

# Client使用自己的私钥对内容进行rsa 解密
    def decrypt(self, en_data):
        """
        en_data:加密过后的数据，传进来是一个字符串
        """
        # base64 解码
        base64_data = base64.b64decode(en_data.encode("utf-8"))

        # 读取私钥
        private_key = RSA.import_key(open("client_private.pem").read())

        # 解密
        cipher_rsa = Cipher_PKC.new(private_key)
        data = cipher_rsa.decrypt(base64_data,None) # None 也可以用 'DecryptError'替换

        return data.decode()

3.4、签名与验签

当然，对于窃听者，有时候也可以对伪造Server给Client发送内容。为此出现了数字签名。也就是Server给Client发送消息的时候，先对消息进行签名，表明自己的身份，并且这个签名无法伪造。具体过程即Server使用自己的私钥对内容签名，然后Client使用Server的公钥进行验签。

签名：

# Server使用自己的私钥对内容进行签名
    def signature(self,data:str):
        """
         RSA私钥签名
        :param data: 明文数据
        :return: 签名后的字符串sign
        """


        # 读取私钥
        private_key = RSA.import_key(open("server_private.pem").read())
        # 根据SHA256算法处理签名内容data
        sha_data= SHA256.new(data.encode("utf-8")) # b类型

        # 私钥进行签名
        signer = Signature_PKC.new(private_key)
        sign = signer.sign(sha_data)

        # 将签名后的内容，转换为base64编码
        sign_base64 = base64.b64encode(sign)
        return sign_base64.decode()
# Client使用Server的公钥对内容进行验签

    def verify(self,data:str,signature:str) -> bool:
        """
        RSA公钥验签
        :param data: 明文数据,签名之前的数据
        :param signature: 接收到的sign签名
        :return: 验签结果,布尔值
        """
        # 接收到的sign签名 base64解码
        sign_data = base64.b64decode(signature.encode("utf-8"))

        # 加载公钥
        piblic_key = RSA.importKey(open("server_public.pem").read())

        # 根据SHA256算法处理签名之前内容data
        sha_data = SHA256.new(data.encode("utf-8"))  # b类型

        # 验证签名
        signer = Signature_PKC.new(piblic_key)
        is_verify = signer.verify(sha_data, sign_data)

        return is_verify

3.5、RSA封装完整代码：

import base64
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5 as Cipher_PKC
from Crypto import Random
from Crypto.Hash import SHA256
from Crypto.Signature import PKCS1_v1_5 as Signature_PKC


class HandleRSA():
    def create_rsa_key(self):
        
        """
        创建RSA密钥
        步骤说明：
        1、从 Crypto.PublicKey 包中导入 RSA，创建一个密码
        2、生成 1024/2048 位的 RSA 密钥
        3、调用 RSA 密钥实例的 exportKey 方法，传入密码、使用的 PKCS 标准以及加密方案这三个参数。
        4、将私钥写入磁盘的文件。
        5、使用方法链调用 publickey 和 exportKey 方法生成公钥，写入磁盘上的文件。
        """
        
        # 伪随机数生成器
        random_gen = Random.new().read
        # 生成秘钥对实例对象：1024是秘钥的长度
        rsa = RSA.generate(1024, random_gen)

        # Server的秘钥对的生成
        private_pem = rsa.exportKey()
        with open("server_private.pem", "wb") as f:
            f.write(private_pem)

        public_pem = rsa.publickey().exportKey()
        with open("server_public.pem", "wb") as f:
            f.write(public_pem)

        # Client的秘钥对的生成
        private_pem = rsa.exportKey()
        with open("client_private.pem", "wb") as f:
            f.write(private_pem)

        public_pem = rsa.publickey().exportKey()
        with open("client_public.pem", "wb") as f:
            f.write(public_pem)

    # Server使用Client的公钥对内容进行rsa 加密
    def encrypt(self, plaintext):
        
        """
        client 公钥进行加密
        plaintext:需要加密的明文文本，公钥加密，私钥解密
        """

        # 加载公钥
        rsa_key = RSA.import_key(open("client_public.pem").read() )

        # 加密
        cipher_rsa = Cipher_PKC.new(rsa_key)
        en_data = cipher_rsa.encrypt(plaintext.encode("utf-8")) # 加密

        # base64 进行编码
        base64_text = base64.b64encode(en_data)

        return base64_text.decode() # 返回字符串

    # Client使用自己的私钥对内容进行rsa 解密
    def decrypt(self, en_data):
        
        """
        en_data:加密过后的数据，传进来是一个字符串
        """
        # base64 解码
        base64_data = base64.b64decode(en_data.encode("utf-8"))

        # 读取私钥
        private_key = RSA.import_key(open("client_private.pem").read())

        # 解密
        cipher_rsa = Cipher_PKC.new(private_key)
        data = cipher_rsa.decrypt(base64_data,None)

        return data.decode()

    # Server使用自己的私钥对内容进行签名
    def signature(self,data:str):
        
        """
         RSA私钥签名
        :param data: 明文数据
        :return: 签名后的字符串sign
        """


        # 读取私钥
        private_key = RSA.import_key(open("server_private.pem").read())
        # 根据SHA256算法处理签名内容data
        sha_data= SHA256.new(data.encode("utf-8")) # b类型

        # 私钥进行签名
        signer = Signature_PKC.new(private_key)
        sign = signer.sign(sha_data)

        # 将签名后的内容，转换为base64编码
        sign_base64 = base64.b64encode(sign)
        return sign_base64.decode()

    # Client使用Server的公钥对内容进行验签

    def verify(self,data:str,signature:str) -> bool:
        
        """
        RSA公钥验签
        :param data: 明文数据,签名之前的数据
        :param signature: 接收到的sign签名
        :return: 验签结果,布尔值
        """
        # 接收到的sign签名 base64解码
        sign_data = base64.b64decode(signature.encode("utf-8"))

        # 加载公钥
        piblic_key = RSA.importKey(open("server_public.pem").read())

        # 根据SHA256算法处理签名之前内容data
        sha_data = SHA256.new(data.encode("utf-8"))  # b类型

        # 验证签名
        signer = Signature_PKC.new(piblic_key)
        is_verify = signer.verify(sha_data, sign_data)

        return is_verify

if __name__ == '__main__':

    mrsa = HandleRSA()
    # mrsa.create_rsa_key()
    e = mrsa.encrypt('hello client, this is a message')
    d = mrsa.decrypt(e)
    print(e)
    print(d)
    #---------------------------------
    sign_data = mrsa.signature("我叫阿登哥")
    is_verify = mrsa.verify(data="我叫阿登哥",signature=sign_data)
    print("签名：\n",sign_data)
    print("验签：\n",is_verify)
    """
    总结
    Pycrypto提供了比较完善的加密算法。RSA广泛用于加密与解密，还有数字签名通信领域。使用Publick/Private秘钥算法中，
    加密主要用对方的公钥，解密用自己的私钥。签名用自己的私钥，验签用对方的公钥。

    - 加密解密：公钥加密，私钥解密
    - 签名验签：私钥签名，公钥验签

    无论是加密解密还是签名验签都使用同一对秘钥对
    """

4. 对称加密与非对称签名结合使用

非对称加密安全性要比对称加密高，但由于算法强度比对称加密复杂，加解密的速度比对称加解密慢。

对称加密算法的特点是计算量小、加密速度快、加密效率高。不足之处是，交易双方都使用同样密钥，安全性得不到保证。常见的对称加密算法有DES、AES 等。

在互联网上传输消息即要保证信息的安全性，又要保证不能有高的延迟，所以通常会将对称加密算法和非对称加密算法联合使用。使用非对称加密算法进行数字签名以及将对称加密算法所用密钥的加密传输，然后再使用对称加密算法对报文进行加解密，即保证了报文传输的安全性，又保证了报文传输的速度，提升了用户体验。

#！/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
===========================
# @Time : 2020/9/5 9:58
# @File  : handle_aes1.py
# @Author: adeng
# @Date  : 2020/9/5
============================
"""
import base64
from Crypto.Cipher import AES


class HandleAES:

    @staticmethod
    def add_to_16(text:str):
        # 考虑到中文长度1个等于3个字节。所以统计text长度。转化为byte再使用len()
        text += (16 -len(text.encode("utf-8"))%16)* "\0" # \0 表示空格
        return text.encode("utf-8")

    @staticmethod
    def aes_encrypt(data, key=b'this is a 16 key'):
        cipher = AES.new(key, AES.MODE_CBC, iv=key)
        cipher_text = cipher.encrypt(HandleAES.add_to_16(data))
        en_data = base64.b64encode(cipher_text)
        return en_data.decode()

    @staticmethod
    def aes_decrypt(data, key=b'this is a 16 key'):
        data = base64.b64decode(data.encode("utf-8"))
        cipher = AES.new(key, AES.MODE_CBC, iv=key)
        decrypt_text = cipher.decrypt(data)
        return decrypt_text.decode().rstrip("\0") # 去除 空格

if __name__ == '__main__':
    print(HandleAES.aes_encrypt("我是阿登啊"))
    print(base64.b64encode("我是阿登啊".encode()).decode())
  
    print(HandleAES.aes_decrypt("7o7zSXJFDdKRw46o3+QUvg=="))
 

客户端–服务端加密–签名–解密案例：

import handle_rsa,handle_aes1

"""
假如 client向 server 发送一句话 text="我太爱你了阿哥哥，咱们谈恋爱吧"


"""
# 文本加密 对称加密AES
text="我太爱你了阿哥哥，咱们谈恋爱吧"
en_text = handle_aes1.HandleAES.aes_encrypt(text)

# cilent端用自己的私钥进行签名
c_text = handle_rsa.HandleRSA().signature(en_text)

# sever端，拿到c_text进行签名，把s_text签名再次发给cilent端

s_text = handle_rsa.HandleRSA().signature(c_text)

#--------------------------------------------------
# client端对sever端的签名进行验签.
bool_result = handle_rsa.HandleRSA().verify(c_text,s_text)

# 如果签名为真，那么开始对en_text进行解密
if bool_result:
    result_text = handle_aes1.HandleAES.aes_decrypt(en_text)
    print(result_text)
    if result_text == text:
        print("解密OK")

《AUTOSAR谱系分解(ETAS工具链)》之总目录