Python-RSA加密实现

实现RSA不对称加密算法的大数据加密

1.加密模块：传入参数：需要加密的字节数据，返回数据：加密后的字节数据
2.解密模块：传入参数：同加密值下加密后的字节数据，返回数据：解密后的字符串

import rsa.common
import rsa


class Rsa_mes(object):
    def __init__(self):
        self.keys = rsa.newkeys(256)

    # rsa 加密
    def rsa_encrypt_bytes(self, bytes_str):
        if not isinstance(bytes_str, bytes):
            return None

        # 导入rsa库
        pubkey = rsa.PublicKey(self.keys[1].n, self.keys[1].e)

        key_length = rsa.common.byte_size(self.keys[1].n)
        max_msg_length = key_length - 11

        count = len(bytes_str) // max_msg_length
        if len(bytes_str) % max_msg_length > 0:
            count = count + 1

        cry_bytes = b''

        # rsa加密要以max_msg_length分组, 每组分别加密(加密的数据长度为key_length, 解密时每key_length长度解密然后相加)
        for i in range(count):
            start = max_msg_length * i
            size = max_msg_length
            content = bytes_str[start: start + size]

            # rsa 分组 加密
            crypto = rsa.encrypt(content, pubkey)

            cry_bytes = cry_bytes + crypto

        return cry_bytes

    # rsa 解密, bytes_string是rsa_encrypt_hex, rsa_encrypt_bytes的返回值
    def rsa_decrypt(self, bytes_string):
        pri_key = rsa.PrivateKey(self.keys[1].n, self.keys[1].e, self.keys[1].d, self.keys[1].p, self.keys[1].q)

        key_length = rsa.common.byte_size(self.keys[1].n)
        if len(bytes_string) % key_length != 0:
            # 如果数据长度不是key_length的整数倍, 则数据是无效的
            return None

        count = len(bytes_string) // key_length
        d_cty_bytes = b''

        # 分组解密
        for i in range(count):
            start = key_length * i
            size = key_length
            content = bytes_string[start: start + size]

            # rsa 分组 解密
            d_crypto = rsa.decrypt(content, pri_key)

            d_cty_bytes = d_cty_bytes + d_crypto

        return d_cty_bytes.decode("utf-8")


rs_mes = Rsa_mes()
a = "hello"
res_en = rs_mes.rsa_encrypt_bytes(bytes_str=a.encode("utf-8"))
print(res_en)
res_de = rs_mes.rsa_decrypt(res_en).decode("utf-8")
print(res_de)

扩展：
1、加密后的字节转换为字符串：
res_byte = rsa_mes.encrypt_bytes(bytes_str=a.encode("utf-8")) # 加密明文
res_str = '{}'.format(res_byte) # 密文转换为字符串
2、转换后的字符串解密
res_byte = eval(res_str) # 获得真实的字节类型
res = rs_mes.rsa_decrypt(res_byte) # 解密，得到明文