RSA加解密工具

# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         encrypt
# Date:         2021/2/26
# -------------------------------------------------------------------------------
import os
import sys
import time

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


class RSAUtil:
    def __init__(self, target: str, public_cert="public.pem", private_cert="private.pem", skip=100, batch_bytes=128):
        """

        :param target: target file path
        :param public_cert: Public key file
        :param private_cert: Secret key file
        """
        self.batch_bytes = batch_bytes
        self.max_patch_bytes = self.batch_bytes - 11
        self.create_cert()
        self.encrypt_cipher = Cipher_pkcs1_v1_5.new(RSA.importKey(open(public_cert).read()))  # 创建用于执行pkcs1_v1_5加密的密码
        self.decrypt_cipher = Cipher_pkcs1_v1_5.new(RSA.importKey(open(private_cert).read()))  # 创建用于执行pkcs1_v1_5解密的密码
        self.target = target

        self.skip = skip  # not used
        self.debug = False

    def create_cert(self):
        if os.path.exists("private.pem"):
            return
        rsa = RSA.generate(self.batch_bytes * 8)
        private_pem = rsa.exportKey()
        with open("private.pem", "wb") as f:
            f.write(private_pem)
        # 公钥
        public_pem = rsa.publickey().exportKey()
        with open("public.pem", "wb") as f:
            f.write(public_pem)

    def encrypt_file(self, file_path):
        with open(file_path, "rb") as f1:
            data = f1.read()
            data_list = [data[i:i + self.max_patch_bytes] for i in range(0, len(data), self.max_patch_bytes)]
            self.log(len(data_list))

            f = open(self.target, mode="wb+")
            for index, tmp_data in enumerate(data_list):
                encrypt_data = self.__encrypt_bytes(tmp_data)
                f.write(encrypt_data)
                self.process_bar(total=len(data_list), now=index)
            f.close()

    def decrypt_file(self, file_path):
        with open(file_path, "rb") as f1:
            data = f1.read()
            data_list = [data[i:i + self.batch_bytes] for i in range(0, len(data), self.batch_bytes)]
            f = open(self.target, mode="wb+")
            for index, encrypt_data in enumerate(data_list):
                decrypt_data = self.__decrypt_bytes(encrypt_data)
                self.log(f"decrypt_data = {decrypt_data}\nlen={len(encrypt_data)}\n\n")
                f.write(decrypt_data)
                self.process_bar(total=len(data_list), now=index)
            f.close()

    def __encrypt_bytes(self, content: bytes):
        return self.encrypt_cipher.encrypt(content)

    def __decrypt_bytes(self, content: bytes):
        return self.decrypt_cipher.decrypt(content, "")

    @staticmethod
    def process_bar(total, now):
        process = int(now * 100 / total)
        sys.stdout.write(f"\r[ {process}% ]" + ">" * process)
        sys.stdout.flush()

    def log(self, strings):
        if self.debug:
            print(strings)


if __name__ == '__main__':
    #  encrypt
    encrypt_start = time.perf_counter()
    rsa = RSAUtil("encrypt.so")
    # rsa.encrypt_file("add.so")
    rsa.encrypt_file("fbalpha2012_libretro.so")
    print(f"encrypt time : {time.perf_counter() - encrypt_start}")

    # decrypt
    decrypt_start = time.perf_counter()
    rsa = RSAUtil("decrypt.so")
    rsa.decrypt_file("encrypt.so")
    print(f"decrypt time : {time.perf_counter() - decrypt_start}")