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

  RSA是1977年由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

  RSA解决了对称加密的一个不足,比如AES算法加密和解密时使用的是同一个秘钥,因此这个秘钥不能公开,因此对于需要公开秘钥的场合,我们需要在加密和解密过程中使用不同的秘钥,加密使用的公钥可以公开,解密使用的私钥要保密,这就是非对称加密的好处。 

  常用的开发语言来实现RSA加密:

  RSA非对称加密算法实现:Java

  RSA非对称加密算法实现:C#

  RSA非对称加密算法实现:Golang

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

 

  公钥与私钥

  公钥与私钥是成对的,一般的,我们认为的是公钥加密、私钥解密、私钥签名、公钥验证,有人说成私钥加密,公钥解密时不对的。

  公钥与私钥的生成有多种方式,可以通过程序生成(下文具体实现),可以通过openssl工具:  

    # 生成一个私钥,推荐使用1024位的秘钥,秘钥以pem格式保存到-out参数指定的文件中,采用PKCS1格式
    openssl genrsa -out rsa.pem 1024 
    # 生成与私钥对应的公钥,生成的是Subject Public Key,一般配合PKCS8格式私钥使用
    openssl rsa -in rsa.pem -pubout -out rsa.pub  

  RSA生成公钥与私钥一般有两种格式:PKCS1和PKCS8,上面的命令生成的秘钥是PKCS1格式的,而公钥是Subject Public Key,一般配合PKCS8格式私钥使用,所以就可能会涉及到PKCS1和PKCS8之间的转换:

    # PKCS1格式私钥转换为PKCS8格式私钥,私钥直接输出到-out参数指定的文件中
    openssl pkcs8 -topk8 -inform PEM -in rsa.pem -outform pem -nocrypt -out rsa_pkcs8.pem
    # PKCS8格式私钥转换为PKCS1格式私钥,私钥直接输出到-out参数指定的文件中
    openssl rsa -in rsa_pkcs8.pem -out rsa_pkcs1.pem

    # PKCS1格式公钥转换为PKCS8格式公钥,转换后的内容直接输出
    openssl rsa -pubin -in rsa.pub -RSAPublicKey_out
    # PKCS8格式公钥转换为PKCS1格式公钥,转换后的内容直接输出
    openssl rsa -RSAPublicKey_in -pubout -in rsa.pub

  现实中,我们往往从pem、crt、pfx文件获取公私和私钥,crt、pfx的制作可以参考:简单的制作ssl证书,并在nginx和IIS中使用,或者使用现成的:https://pan.baidu.com/s/1MJ5YmuZiLBnf-DfNR_6D7A (提取码:c6tj),密码都是:123456

 

  Python实现

  首先使用pip两个第三方包:  

    # 用于从crt、pfx等文件读取公私秘钥
    pip install pyOpenSSL
    # 用RSA加密解密签名验证等(如果安装不了,先卸载旧版本再安装:pip uninstall pycrypto)
    pip install pycryptodome

  接着封装一个模块RsaUtil:  

  
# 需要安装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
RsaUtil

  生成RSA的公私秘钥:  

# 生成rsa公私秘钥
(publicKey, privateKey) = RsaUtil.generate_rsa_key(use_pkcs8)

  生成秘钥后,需要保存,一般保存到pem文件中:  

# 将公私秘钥写入pem文件,filePath是文件目录
RsaUtil.write_to_pem(publicKey, False, os.path.join(filePath, "rsa.pub"))
RsaUtil.write_to_pem(privateKey, True, os.path.join(filePath, "rsa.pem"))

  可以保存到pem文件中,当然也可以从pem文件中读取了:  

# 从pem文件中读取秘钥,filePath是文件目录
publicKey = RsaUtil.read_from_pem(os.path.join(filePath, "rsa.pub"))
privateKey = RsaUtil.read_from_pem(os.path.join(filePath, "rsa.pem"))

  还可以从crt证书中读取公钥,而crt文件不包含私钥,因此需要单独获取私钥:

# 从crt文件读取,filePath是文件目录
publicKey = RsaUtil.read_public_key_from_crt(os.path.join(filePath, "demo.crt"))
privateKey = RsaUtil.read_from_pem(os.path.join(filePath, "demo.key"))

  pfx文件中包含了公钥和私钥,可以很方便就读取到:

# 从demo.pfx文件读取(demo.pfx采用的是pkcs1),filePath是文件目录
(publicKey, privateKey) = RsaUtil.read_from_pfx(os.path.join(filePath, "demo.pfx"), "123456")

  有时候我们还可能需要进行秘钥的转换:

# Pkcs8格式公钥转换为Pkcs1格式公钥
publicKey = RsaUtil.pkcs8_to_pkcs1(publicKey)
# Pkcs8格式私钥转换为Pkcs1格式私钥
privateKey = RsaUtil.pkcs8_to_pkcs1(privateKey)
# Pkcs1格式公钥转换为Pkcs8格式公钥
publicKey = RsaUtil.pkcs1_to_pkcs8(publicKey)
# Pkcs1格式私钥转换为Pkcs8格式私钥
privateKey = RsaUtil.pkcs1_to_pkcs8(privateKey)

  有了公钥和私钥,接下就就能实现加密、解密、签名、验证签名等操作了:

encryptText = RsaUtil.rsa_encrypt(text, publicKey)
print("", text, "】经过【RSA】加密后:", encryptText)

decryptText = RsaUtil.rsa_decrypt(encryptText, privateKey)
print("", encryptText, "】经过【RSA】解密后:", decryptText)

signature = RsaUtil.sign(text, privateKey, Hash.MD5)
print("", text, "】经过【RSA】签名后:", signature)

result = RsaUtil.verify(text, publicKey, signature, Hash.MD5)
print("", text, "】的签名【", signature, "】经过【RSA】验证后结果是:", result)

  完整的demo代码:

import RsaUtil
from Crypto import Hash
import os

text = "上山打老虎"
use_pkcs8 = True
filePath = os.getcwd()
print("文件路径:", filePath)

# 生成rsa公私秘钥
(publicKey, privateKey) = RsaUtil.generate_rsa_key(use_pkcs8)
# 从pem文件中读取秘钥,filePath是文件目录
# publicKey = RsaUtil.read_from_pem(os.path.join(filePath, "rsa.pub"))
# privateKey = RsaUtil.read_from_pem(os.path.join(filePath, "rsa.pem"))
# 从demo.pfx文件读取(demo.pfx采用的是pkcs1),filePath是文件目录
# (publicKey, privateKey) = RsaUtil.read_from_pfx(os.path.join(filePath, "demo.pfx"), "123456")
# 从crt文件读取,filePath是文件目录
# publicKey = RsaUtil.read_public_key_from_crt(os.path.join(filePath, "demo.crt"))
# privateKey = RsaUtil.read_from_pem(os.path.join(filePath, "demo.key"))

# 将公私秘钥写入pem文件,filePath是文件目录
RsaUtil.write_to_pem(publicKey, False, os.path.join(filePath, "rsa.pub"))
RsaUtil.write_to_pem(privateKey, True, os.path.join(filePath, "rsa.pem"))

# Pkcs8格式公钥转换为Pkcs1格式公钥
publicKey = RsaUtil.pkcs8_to_pkcs1(publicKey)
# Pkcs8格式私钥转换为Pkcs1格式私钥
privateKey = RsaUtil.pkcs8_to_pkcs1(privateKey)
# Pkcs1格式公钥转换为Pkcs8格式公钥
publicKey = RsaUtil.pkcs1_to_pkcs8(publicKey)
# Pkcs1格式私钥转换为Pkcs8格式私钥
privateKey = RsaUtil.pkcs1_to_pkcs8(privateKey)

encryptText = RsaUtil.rsa_encrypt(text, publicKey)
print("", text, "】经过【RSA】加密后:", encryptText)

decryptText = RsaUtil.rsa_decrypt(encryptText, privateKey)
print("", encryptText, "】经过【RSA】解密后:", decryptText)

signature = RsaUtil.sign(text, privateKey, Hash.MD5)
print("", text, "】经过【RSA】签名后:", signature)

result = RsaUtil.verify(text, publicKey, signature, Hash.MD5)
print("", text, "】的签名【", signature, "】经过【RSA】验证后结果是:", result)

 

posted @ 2021-06-18 20:12  没有星星的夏季  阅读(1067)  评论(0编辑  收藏  举报