由于自身与客户经常对接业务接口，对RSA加密的方式有一些了解。通常我们客户用的是PHP或JAVA较多，像PYTHON这样的客户很少，近期就碰到一个客户用的就是这个语言，但研究了很久发现PYTHON语言中一些已知库中里面RSA加密没有提供[私钥加密公钥解密的方法]。接下来说正题！

灵感来源于C#中的Org.BouncyCastle.Crypto.Engines一段代码

public BigInteger ProcessBlock( BigInteger input)
        {
            if (key is RsaPrivateCrtKeyParameters)  //这里判断了KEY是否为私钥，如果不是私钥看返回的代码
            {
                //
                // we have the extra factors, use the Chinese Remainder Theorem - the author
                // wishes to express his thanks to Dirk Bonekaemper at rtsffm.com for
                // advice regarding the expression of this.
                //
                RsaPrivateCrtKeyParameters crtKey = (RsaPrivateCrtKeyParameters)key;

                BigInteger p = crtKey.P;;
                BigInteger q = crtKey.Q;
                BigInteger dP = crtKey.DP;
                BigInteger dQ = crtKey.DQ;
                BigInteger qInv = crtKey.QInv;

                BigInteger mP, mQ, h, m;

                // mP = ((input Mod p) ^ dP)) Mod p
                mP = (input.Remainder(p)).ModPow(dP, p);

                // mQ = ((input Mod q) ^ dQ)) Mod q
                mQ = (input.Remainder(q)).ModPow(dQ, q);

                // h = qInv * (mP - mQ) Mod p
                h = mP.Subtract(mQ);
                h = h.Multiply(qInv);
                h = h.Mod(p);               // Mod (in Java) returns the positive residual

                // m = h * q + mQ
                m = h.Multiply(q);
                m = m.Add(mQ);

                return m;
            }

            return input.ModPow(key.Exponent, key.Modulus);//这个代码给了我启发
        }

经过以上的案例，于是我在PYTHON中Crypto库中找到加密的代码

文件名：RSA.PY  路径：Crypto\PublicKey\RSA.py

下载下载RSA.PY（将此文件替换CRYPTO库中的Crypto\PublicKey\RSA.py替换，使用以下方法）

为了保证源方法不变的情况做了以下修改

修改内容：增加方法：has_public(判断是否为公钥)，修改_decrypt，_encrypt （修改加解密方法使其支持私钥加密公钥解密）代码如下：

    def has_public(self):
        """Whether this is an RSA public key"""
        return hasattr(self,"_e") and not self.has_private()


    def _encrypt(self, plaintext):
        if not 0 <= plaintext < self._n:
            raise ValueError("Plaintext too large")
        if self.has_public():
            return int(pow(Integer(plaintext), self._e, self._n))
        elif self.has_private():
            return int(pow(Integer(plaintext), self._d, self._n))
        else:
            raise TypeError("This is not a key")


    def _decrypt(self, ciphertext):
        if not 0 <= ciphertext < self._n:
            raise ValueError("Ciphertext too large")
        if self.has_private():
            # raise TypeError("This is not a private key")

            # Blinded RSA decryption (to prevent timing attacks):
            # Step 1: Generate random secret blinding factor r,
            # such that 0 < r < n-1
            r = Integer.random_range(min_inclusive=1, max_exclusive=self._n)
            # Step 2: Compute c' = c * r**e mod n
            cp = Integer(ciphertext) * pow(r, self._e, self._n) % self._n
            # Step 3: Compute m' = c'**d mod n       (normal RSA decryption)
            m1 = pow(cp, self._dp, self._p)
            m2 = pow(cp, self._dq, self._q)
            h = ((m2 - m1) * self._u) % self._q
            mp = h * self._p + m1
            # Step 4: Compute m = m**(r-1) mod n
            result = (r.inverse(self._n) * mp) % self._n
            # Verify no faults occurred
            if ciphertext != pow(result, self._e, self._n):
                raise ValueError("Fault detected in RSA decryption")
            return result
        elif self.has_public():
            return pow(Integer(ciphertext), self._e, self._n)
        else:
            raise TypeError("This is not a key")

PYTHON加解密方法：

1、读取证书CER/PFX扩展名文件  文件：RsaReadUtil.py

from OpenSSL import crypto

class RsaReadUtil:

    @staticmethod
    def get_private_key(pfx_file_path,password):
        pfx = crypto.load_pkcs12(open(pfx_file_path,'rb').read(),password)
        res = crypto.dump_privatekey(crypto.FILETYPE_PEM,pfx.get_privatekey())
        return res.strip()

    @staticmethod
    def get_public_key(cer_file_path):
        cert = crypto.load_certificate(crypto.FILETYPE_PEM, open(cer_file_path, "rb").read())
        res = crypto.dump_publickey(crypto.FILETYPE_PEM, cert.get_pubkey()).decode("utf-8")
        return res.strip()

2、核心加解密方法，支持公钥加密私钥解密，私钥加密公钥解密

from Crypto.Cipher import PKCS1_v1_5 as PKCS1_v1_5_cipper
from Crypto.PublicKey import RSA


import binascii
import base64
import  RsaReadUtil

class RsaUtil:
    @staticmethod
    def En_Core(srcdata,publick_keys):
        rsakey = RSA.importKey(publick_keys)
        cipher = PKCS1_v1_5_cipper.new(rsakey)
        block_size = int(rsakey.n.bit_length() / 8 - 11)
        en_code_data = base64.b64encode(str(srcdata).encode("utf-8"))
        print(en_code_data)
        en_data = bytes()
        while en_code_data:
            input_data = en_code_data[:block_size]
            en_code_data = en_code_data[block_size:]
            en_data += cipher.encrypt(input_data)
        return en_data.hex()

    @staticmethod
    def En_Public(src_data,cer_key_path):
        # ---公钥加密---#
        return RsaUtil.En_Core(src_data, RsaReadUtil.RsaReadUtil.get_public_key(cer_key_path))

    @staticmethod
    def En_Private(src_data,pfx_key_path,pfx_pwd):
        # ---私钥加密---#
        return RsaUtil.En_Core(src_data,RsaReadUtil.RsaReadUtil.get_private_key(pfx_key_path,pfx_pwd))

    @staticmethod
    def De_Core(srcdata,private_kes):
        rsakey = RSA.importKey(private_kes)
        cipher = PKCS1_v1_5_cipper.new(rsakey)
        block_size = int(rsakey.n.bit_length() / 8)

        de_code_data = binascii.unhexlify(srcdata)
        out_data = bytes()
        while de_code_data:
            input_data = de_code_data[:block_size]
            de_code_data = de_code_data[block_size:]
            out_data += cipher.decrypt(input_data,'')
        return str(base64.b64decode(out_data),encoding="utf-8")

    @staticmethod
    def De_Private(src_data,pfx_key_path,pfx_pwd):
        # ---私钥解密---#
        return RsaUtil.De_Core(src_data,RsaReadUtil.RsaReadUtil.get_private_key(pfx_key_path,pfx_pwd))

    @staticmethod
    def De_Public(src_data,cer_key_path):
        # ---公钥解密---#
        return RsaUtil.De_Core(src_data,RsaReadUtil.RsaReadUtil.get_public_key(cer_key_path))

3、测试代码：

import RsaUtil
from SignatureUtil import Signature

cer_path = "D:\\********.cer"
pfx_path = "D:\\*******.pfx"
pfx_pwd = "*****"

desc = "把导出私钥及设置的密码和下载的配到生产环境"
print(desc)
print("私钥加密>>>")
pub_en_str = RsaUtil.RsaUtil.En_Private(desc,pfx_path,pfx_pwd)
print(pub_en_str)
print("公钥解密>>>")
pri_de_str = RsaUtil.RsaUtil.De_Public(pub_en_str,cer_path)
print(pri_de_str)

print("公钥加密>>>")
pub_en_str = RsaUtil.RsaUtil.En_Public(desc,cer_path)
print(pub_en_str)

print("私钥解密>>>")
pri_de_str = RsaUtil.RsaUtil.De_Private(pub_en_str,pfx_path,pfx_pwd)
print(pri_de_str)

以上代码测试OK