python 的rsa 算法 str操作引用了rsa_alg 文件

"""
Author: tanglei
DateTime:2024-11-18 完成
微信：ciss_cedar
欢迎一起学习
文件名：rsa_apply
"""
from rsa_alg import Rsa
from symmetric_apply import AlgName, CipherMode, symmetric_encrypt, symmetric_decrypt


class Rsa_Apply:

    def __init__(self,private_key):
        self.private_key=private_key
        self.public_key=private_key.public_key()
        if(private_key is None):
            self.private_key = Rsa.rsa_gen_keypair(2048)
            self.public_key= self.private_key.public_key()
    @staticmethod
    def rsa_gen_keypair():
        public_key,private_key = Rsa.rsa_gen_keypair()
        return public_key,private_key

    def get_private_key_pem(self):
        myRsa=Rsa(self.private_key)
        private_key_pem=myRsa.get_private_key_pem()
        return private_key_pem

    def get_public_key_pem(self):
        myRsa=Rsa(self.private_key)
        public_key_pem=myRsa.get_public_key_pem()
        return public_key_pem

    def get_public_key_n_e(self):
        public_numbers = self.public_key.public_numbers()
        n = public_numbers.n
        e = public_numbers.e
        return n,e

    def get_private_key_p_q_d(self):
        private_numbers = self.private_key.private_numbers()
        p = private_numbers.p
        q = private_numbers.q
        d = private_numbers.d
        return p,q,d

    def rsa_sign(self,source:str):
        source=source.encode()
        myRsa = Rsa(self.private_key)
        sign_source=myRsa.rsa_sign(source)
        return sign_source.hex().upper()


    @staticmethod
    def rsa_verify(public_key,sign_source:str,source:str):
        sign_source=bytes.fromhex(sign_source)
        source=source.encode()
        #myRsa = Rsa(self.private_key)
        verify_flag=Rsa.rsa_verify(public_key,sign_source,source)
        return verify_flag

    # private_key 可以获取public_key ,只要初始化类后就可以使用public_key验签，只需要传入private_key即可
    def rsa_verify_private_key(self,sign_source:str,source:str):
        sign_source=bytes.fromhex(sign_source)
        source=source.encode()
        myRsa = Rsa(self.private_key)
        verify_flag=myRsa.rsa_verify(sign_source,source)
        return verify_flag

    @staticmethod
    #没有密码，password=None
    def read_pem(filepath,password=None):
        public_key, private_key=Rsa.read_pem(filepath,password)
        return public_key, private_key

    @staticmethod
    def get_key_from_pem_str(private_key_pem_str,public_key_pem_str,password=None):
        public_key, private_key=Rsa.get_key_from_pem_str(private_key_pem_str,public_key_pem_str,password=password)
        return public_key,private_key

    def write_pem(self,filepath,password=None):
        myRsa = Rsa(self.private_key)
        myRsa.write_pem(filepath,password)

    @staticmethod
    def rsa_encrypt(public_key, source):
        # 加密操作
        source=source.encode()
        #myRsa = Rsa(self.private_key)
        enc_source =Rsa.rsa_encrypt(public_key,source)
        return enc_source.hex().upper()

    # private_key 可以获取public_key ,只要初始化类后就可以使用public_key加密，只需要传入private_key即可
    def rsa_encrypt_private_key(self, source:str):
        # 加密操作
        source=source.encode()
        myRsa = Rsa(self.private_key)
        enc_source =myRsa.rsa_encrypt_private_key(source)
        return enc_source.hex().upper()

    def rsa_decrypt(self, enc_source):
        enc_source=bytes.fromhex(enc_source)
        myRsa = Rsa(self.private_key)
        source =myRsa.rsa_decrypt(enc_source)
        return source.decode()
    @staticmethod
    def rsa_digital_envelope(public_key, aes_key, source):
            # 加密操作
            alg_name = AlgName.AES.value
            mode = CipherMode.ECB.value
            iv=aes_key
            enc_source = symmetric_encrypt(aes_key, iv, source, mode, alg_name)
            #plain = symmetric_decrypt(aes_key, iv, cipher, mode, alg_name)

            enc_aes_key =Rsa_Apply.rsa_encrypt(public_key,aes_key)

            return enc_aes_key, enc_source

    @staticmethod
    #private_key 可以获取public_key ,只要初始化类后就可以使用public_key加密，只需要传入private_key即可
    def rsa_digital_envelope_private_key(private_key, aes_key, source):
            # 加密操作
            alg_name = AlgName.AES.value
            mode = CipherMode.ECB.value
            iv=aes_key
            enc_source = symmetric_encrypt(aes_key, iv, source, mode, alg_name)
            #plain = symmetric_decrypt(aes_key, iv, cipher, mode, alg_name)
            #myRsa = Rsa(private_key)
            enc_aes_key =Rsa.rsa_encrypt(private_key,aes_key)

            return enc_aes_key, enc_source
    @staticmethod
    def rsa_digital_envelope_decrypt(private_key, enc_eas_key, enc_source):
            # 解密操作
            myRsa = Rsa_Apply(private_key)
            aes_key = myRsa.rsa_decrypt(enc_eas_key)
            alg_name = AlgName.AES.value
            mode = CipherMode.ECB.value
            iv = aes_key
            source = symmetric_decrypt(aes_key, iv, enc_source, mode, alg_name)
            return aes_key, source

def main():
    #private_key = None
    #public_key, private_key =Rsa.rsa_gen_keypair()
    #print(f'private_key={str(private_key)}')
    #print(f'public_key={str(public_key)}')
    password = 'simkey@20181016'
    filepath = 'D:/Python/backup/RSA'
    public_key, private_key = Rsa_Apply.read_pem(filepath,password)
    myRsa = Rsa_Apply(private_key)
    # myRsa.write_pem(filepath)
    private_key_pem = myRsa.get_private_key_pem()
    public_key_pem = myRsa.get_public_key_pem()
    print(f'private_key_pem={private_key_pem}')
    print(f'public_key_pem={public_key_pem}')

    n,e=myRsa.get_public_key_n_e()
    print(f'n={n}')
    print(f'e={e}')

    p,q,d=myRsa.get_private_key_p_q_d()
    print(f'p={p}')
    print(f'q={q}')
    print(f'd={d}')


    #此填充最大可以加密190个字符
    source = ('1')
    enc_source = myRsa.rsa_encrypt(public_key,source)
    print(f'enc_source={enc_source}')

    source = myRsa.rsa_decrypt(enc_source)
    print(f'source={source}')

    source = '1'
    sign_source = myRsa.rsa_sign(source)
    print(f'sign_source={sign_source}')

    source = '1'
    verify_flag = myRsa.rsa_verify(public_key,sign_source, source)
    print(f'verify_flag={verify_flag}')

    source = '2'
    verify_flag = myRsa.rsa_verify(public_key,sign_source, source)
    print(f'verify_flag={verify_flag}')

if __name__ == '__main__':
    main()