RSA非对称加密算法实现：Python

# 需要安装OpenSSL包：pip install pyOpenSSL
# 需要安装pycrypto包：pip install pycryptodome
from Crypto import Random, Hash
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5 as PKCS1_v1_5_Cipher
from Crypto.Signature import PKCS1_v1_5 as PKCS1_v1_5_Signature
from Crypto.IO import PEM, PKCS8
from OpenSSL import crypto
from Crypto.Util.asn1 import (DerSequence, DerBitString, DerObjectId, DerNull)


# pkcs1格式转换为pkcs8
def pkcs1_to_pkcs8(buffer):
    rsakey = RSA.importKey(buffer)
    if rsakey.has_private():
        return PKCS8.wrap(buffer, RSA.oid, None)
    return rsakey.exportKey("DER")


# pkcs8格式转换为pkcs1
def pkcs8_to_pkcs1(buffer):
    rsakey = RSA.importKey(buffer)
    if rsakey.has_private():  # 私钥
        return PKCS8.unwrap(buffer, None)[1]

    spki = DerSequence().decode(buffer, nr_elements=2)
    algo = DerSequence().decode(spki[0], nr_elements=(1, 2))
    algo_oid = DerObjectId().decode(algo[0])
    spk = DerBitString().decode(spki[1]).value

    if len(algo) == 1:
        algo_params = None
    else:
        try:
            DerNull().decode(algo[1])
            algo_params = None
        except:
            algo_params = algo[1]

    if algo_oid.value != RSA.oid or algo_params is not None:
        raise ValueError("No RSA subjectPublicKeyInfo")
    return spk


# 生成RSA加密的公私密钥
def generate_rsa_key(use_pkcs8=False):
    rsa_key = RSA.generate(1024, Random.new().read)  # 1024位
    private_key = rsa_key.exportKey("DER", pkcs=1)
    public_key = rsa_key.publickey().exportKey("DER")  # subject_public_key
    if use_pkcs8:
        private_key = pkcs1_to_pkcs8(private_key)
    else:
        public_key = pkcs8_to_pkcs1(public_key)

    return public_key, private_key


# 从pem文件中读取秘钥
def read_from_pem(pen_file_ame):
    with open(pen_file_ame, 'r') as f:
        t = PEM.decode(f.read())
        if t[2]:
            raise ValueError("fail to read pem")
        return t[0]


# 将秘钥写入pem文件
def write_to_pem(buffer, is_private_key, pen_file_ame):
    if is_private_key:
        str = PEM.encode(buffer, "RSA PRIVATE KEY")
    else:
        str = PEM.encode(buffer, "RSA PUBLIC KEY")

    with open(pen_file_ame, 'w') as f:
        f.write(str)


# 从crt文件中读取公钥
def read_public_key_from_crt(crt_file_name):
    with open(crt_file_name, 'rb') as f:
        cert = crypto.load_certificate(crypto.FILETYPE_PEM, f.read())
        return crypto.dump_publickey(crypto.FILETYPE_PEM, cert.get_pubkey())


# 从pfx文件中读取公私钥
def read_from_pfx(pfx_file_name, password):
    with open(pfx_file_name, 'rb') as f:
        pfx = crypto.load_pkcs12(f.read(), bytes(password, encoding="utf-8"))
        cert = pfx.get_certificate()
        _public_key = crypto.dump_publickey(crypto.FILETYPE_PEM, cert.get_pubkey())
        _privat_key = crypto.dump_privatekey(crypto.FILETYPE_PEM, pfx.get_privatekey())
        return _public_key, _privat_key


# RSA使用公钥加密
def rsa_encrypt(value, public_key):
    rsakey = RSA.importKey(public_key)
    cipher = PKCS1_v1_5_Cipher.new(rsakey)
    buffer = cipher.encrypt(value.encode("utf-8"))
    return buffer.hex()  # 使用hex格式输出


# RSA使用私钥解密
def rsa_decrypt(value, private_key):
    rsakey = RSA.importKey(private_key)
    cipher = PKCS1_v1_5_Cipher.new(rsakey)
    buffer = bytes.fromhex(value)  # 读取hex格式数据
    buffer = cipher.decrypt(buffer, Random.new().read)
    return buffer.decode("utf-8")


# RSA使用私钥签名
def sign(value, private_ey, halg=Hash.MD5):
    rsakey = RSA.importKey(private_ey)
    signer = PKCS1_v1_5_Signature.new(rsakey)

    hash = halg.new()
    hash.update(value.encode("utf-8"))
    buffer = signer.sign(hash)
    return buffer.hex()  # 使用hex格式输出


# RSA使用公钥验证签名
def verify(value, public_key, signature, halg=Hash.MD5):
    rsakey = RSA.importKey(public_key)
    verifier = PKCS1_v1_5_Signature.new(rsakey)

    hash = halg.new()
    hash.update(value.encode("utf-8"))

    buffer = bytes.fromhex(signature)  # 读取hex格式数据
    result: bool = verifier.verify(hash, buffer)
    return result