Rsa 加密的使用

Rsa 加密的使用

概述：AES 和 DES 都是对称加密算法,加密和解密的时候都是相同的密钥;非对称加密算法加密和解密的密钥是不相同的，分为公钥和私钥;最常见的非对称加密算法是RSA加密算法!

公钥: 公开的密钥，对数据进行加密
私钥: 私密的密钥，对数据进行解密

非对称加密算法在使用的时候，通常会将公钥发送给客户端，客户端将数据进行加密之后发送给服务端，服务端使用私钥进行解密，获取传递的数据信息；因此非对称加密相对于对称加密的算法安全性更高，即使公钥被获取之后，信息仍旧是安全的;

常见的非对称加密的算法有：RSA,DSA,RSA是使用比较广泛的非对称加密算法;

1.RSA 加密解密

安装:

pip install pycryptodome

RSA 在加密之前，需要首先创建公钥和私钥;

1.1 获取密钥信息

密钥分为公钥和私钥，在数据加密之前进行获取，通常会存储在.pem文件中进行保存，特别注意要保护私钥的安全；

# -*- coding: utf-8 -*-
"""使用 RSA 加密算法
"""
import base64
 
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
from Crypto import Random
 
gen_random = Random.new  # 随机标志,类似算法的随机种子;
 
# 生成密钥
rsa_key = RSA.generate(1024)  # 生成密钥的长度; 1024,2048,3072三个长度的值
# print(rsa_key.public_key().export_key())
 
with open("rsa_key.pem", 'wb') as fp:
    # 将公钥写入文件,公钥的值是字节的类型
    fp.write(rsa_key.public_key().export_key())
 
with open("pri_key.pem", 'wb') as fp:
    # 将私钥写入二进制文件;
    fp.write(rsa_key.export_key())

1.2 数据加密

数据加密的主要步骤是加载公钥信息,实例化加密器，进行数据加密;

# -*- coding: utf-8 -*-
""" 数据实现 RSA 加密解密;
"""
import base64
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
 
data = "现在已经十点多了,有点困"
with open("rsa_key.pem", mode="r") as fp:
    public_key = fp.read()  # 读取公钥信息
    rsa_key = RSA.importKey(public_key)  # 返回公钥对象;
    # 创建 rsa 加密的加密器
    rsa = PKCS1_v1_5.new(rsa_key)
    # 进行数据的加密
    result = rsa.encrypt(data.encode("utf-8"))
    # 将加密后的字节信息处理成 base64 的字符串信息;
    b64_result = base64.b64encode(result).decode("utf-8")
    print(b64_result)

1.3 数据解密

与加密方式相似;

# -*- coding: utf-8 -*-
""" 数据实现 RSA 加密解密;
"""
import base64
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
 
data = "JA6PCrJCj7Hw2/szF3SOoCcPqpx6A32JCShYq9HpAL59DTy0hjuPs65zxj3gVeKiibQ9efX0A7o6tbFEkdfhPz9TK8GfraN8oMHbjQMBA9Tbw4EDFHIc/F+TCJLrCBtY156jF+QSjL8y2IcWgQsYBZ90LxFcbtE6RVPgqRdn7b4="
with open("pri_key.pem", 'r') as fp:
    # 读取私钥
    pri_key = fp.read()
    # 加载私钥对象
    rsa_key = RSA.importKey(pri_key)
    # 构建解密器
    rsa = PKCS1_v1_5.new(rsa_key)
    # 进行数据解密,解密前需要现将base64进行解码;
    result = rsa.decrypt(base64.b64decode(data), None)
    print(result.decode("utf-8"))

1.4 rsa 加密的封装

# -*- coding: utf-8 -*-
""" 封装 RSA 算法的加密流程信息;
"""
import os
 
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
 
 
class RsaUtil(object):
    """封装 RSA 加密算法的常用方法;
    """
 
    SECRET_KEY_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'key')
 
    @classmethod
    def get_secret_key(cls, key_length: int, public_key_name: str, private_key_name: str):
        """
        获取加密使用的公钥和私钥信息;
        :param key_length: 获取迷密钥的长度信息,限制取值: 1024,2048,3072;
        :param public_key_name: 存放公钥信息的文件名称, 建议使用 .pem 形式的文件;
        :param private_key_name: 存放私钥文件的名称, 建议使用 .pem 形式的文件;
        :return: None
        """
        rsa_key = RSA.generate(key_length)
        file_public = os.path.join(cls.SECRET_KEY_PATH, public_key_name)
        file_private = os.path.join(cls.SECRET_KEY_PATH, private_key_name)
        # 将公钥写进文件中
        with open(file_public, "wb") as fp:
            fp.write(rsa_key.public_key().export_key())
        # 将私钥写进文件中
        with open(file_private, "wb") as fp:
            fp.write(rsa_key.export_key())
 
    @classmethod
    def encrypt_data(cls, public_key_name: str, data: bytes) -> bytes:
        """
        rsa 的数据加密;
        :param public_key_name: 数据加密使用的公钥文件的名称;
        :param data: 被加密的字节信息;
        :return: bytes; 加密返回的字节信息;
        """
        file_name = os.path.join(cls.SECRET_KEY_PATH, public_key_name)
        with open(file_name, "r") as fp:
            # 读取公钥信息,创建密钥对象
            public_key = fp.read()
            rsa_key = RSA.importKey(public_key)
            # 创建 rsa 加密器
            rsa = PKCS1_v1_5.new(rsa_key)
            # 进行数据的加密;
            result = rsa.encrypt(data)
            return result
 
    @classmethod
    def decrypt_data(cls, private_key_name: str, data: bytes) -> bytes:
        """
        数据信息的解密;
        :param private_key_name: 解密使用的私钥文件名称;
        :param data: 被加密后的字节信息;
        :return: bytes; 返回解密后的信息;
        """
        file_name = os.path.join(cls.SECRET_KEY_PATH, private_key_name)
        with open(file_name,'r') as fp:
            # 读取私钥信息,实例化私钥对象
            private_key = fp.read()
            rsa_key = RSA.importKey(private_key)
            # 构建解密器
            rsa = PKCS1_v1_5.new(rsa_key)
            # 进行数据的解密
            result = rsa.decrypt(data, None)
            return result
 
 
if __name__ == '__main__':
    # 1. 数据加密测试;
    v = RsaUtil.encrypt_data("public_key.pem", "吃了吗？".encode("utf-8"))
    print(v)  # 前后端传输中的时候可以使用base64将字节信息进行编码
    # 2. 数据解密测试;
    sv = RsaUtil.decrypt_data("private_key.pem", v)
    print(sv.decode())

2.RSA在前后端的使用

在前后端交互中，RSA 通常是在前端完成数据的加密,将公钥放置在前端中，即使公钥暴露数据信息仍然是无法被解密得到；

2.1 RSA 在前端的使用

参考文章:https://blog.csdn.net/gkf6104/article/details/125848597

使用的第三方库:https://github.com/travist/jsencrypt,依赖于jsencrypt

import JSEncrypt from 'jsencrypt';
const encryptor = new JSEncrypt();
const pubKey = '-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArBYpsjeeE7RG8XBsCbxf
Ra38w/ktBkqQvwDdkYCNt4M6w24AiEgIKRHeKti4abEf+xRESWmKADkaeiX2lX4D
1R2TiTtFAEpOsubfcndJD1hEYYM9MBjya9nS+6OtZV40R3emevXUbjyQsmCWN2Pc
M3dPvawRDgRj+BEtTHSY7VORhDTcvWfKWgvkc98IGxPVbCB2XEwwBBfRSUapl/pp
lhkefnfPZutv+SOXbGFYdImAeJozQYfVeMBdHlTvJP7nFvowCuM5YkCLq7X8L6cX
1FiaoEzM7oXia3tkrtUnCH4ar1tHjQbZnXn4m63gtEKnEgFsKo1IWDdAK4dXCMO/
8wIDAQAB
-----END PUBLIC KEY-----';
encryptor.setPublicKey(pubKey);
const enPassword = encryptor.encrypt(password)

2.2 RSA 在后端的使用

RSA 在后端主要是使用私钥，加密前端传递过来的数据进行处理，解密之后数据进行一系列的操作；

# -*- coding: utf-8 -*-
 
from flask import Flask, request, jsonify
from utils.rsa_utils import RsaUtil
 
app = Flask(__name__)
 
 
@app.route('/home')
def index():
    data = request.args.get("data")
    data_decrypt = RsaUtil.decrypt_data("private_key.pem", data.encode())
    # 解密后可以进行数据的校验与存储等操作
    print(data_decrypt)
    return "请求成功执行"
 
if __name__ == '__main__':
    app.run()

继续努力，终成大器;