关于自研加密算法的解密

研发了个加密算法，但是太复杂写不出解密来，有谁能帮忙写一下吗。

'''
Name : Double-key imitation-RSA encryption algorithm. ---DKREA
Author : Star Wolf
Version : 1.0
'''


import random
from AES import *
import codecs

class error:
    def __init__(self) -> None:
        pass
    def E_KEY(lang):
        if(not lang in [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]):
            ex = Exception('The lang must in 4-31')
            raise ex

class Processing:
    def __init__(self) -> None:
        pass
    def ruest_key():
        a = []
        for i in range(62):
            a.append(chr(i+65))
        return a
    def Generate_key(lang):
        word_list = Processing.ruest_key()
        a = []
        for __count in range(lang):
            a.append(random.choice(word_list))
        return(a)
    def encode_key(lang):
        error.E_KEY(lang)
        K1 = ''.join(Processing.Generate_key(lang))
        K2 = ''.join(Processing.Generate_key(lang))
        K1A = ''.join(Processing.Generate_key(lang))
        K2A = ''.join(Processing.Generate_key(lang))
        K1B = AES_code.AES_encrypt(K1,K1A)
        K2B = AES_code.AES_encrypt(K2,K2A)
        K = ''.join([K1,K2])
        KEY1 = [K1A,K2B]
        KEY2 = [K2A,K1B]
        print([K,KEY1,KEY2])
        return [K,KEY1,KEY2]
    def decode_key(KEY1,KEY2):
        E_K1 = KEY1[1]#K2B
        E_K2 = KEY2[1]#K1B
        K_K1 = KEY2[0]#K2A
        K_K2 = KEY1[0]#K1A
        KEY2 = AES_code.AES_decrypt(E_K1,K_K1)
        KEY1 = AES_code.AES_decrypt(E_K2,K_K2)
        return(''.join([KEY1,KEY2]))

class circle:
    def __init__(self) -> None:
        pass
    def encode(KEY,data):
        KEY_list = []
        for i in KEY:
            #print(i)
            KEY_list.append(ord(str(i)))
        data_list = []
        for i in data:
            data_list.append(ord(str(i)))
        circle_Key = Processing.ruest_key()
        circle_Key_list = []
        for i in circle_Key:
            circle_Key_list.append(ord(str(i)))
        i_K = 0
        lang = len(KEY)
        KEY = 0
        data_H_list = []
        for data in data_list:
            KEY = KEY+KEY_list[i_K%lang]
            KEY = KEY % 62
            data_H = int(data)+int(circle_Key_list[KEY])
            data_H_list.append(data_H)
            i_K += 1
        return(data_H_list,KEY,i_K%lang)
    def decode(KEY,data,K_j,C_j):
        pass


class core_DKREA:
    def __init__(self) -> None:
        pass
    def encode(lang,data):
        K = Processing.encode_key(lang)
        KEY = K[0]


# if __name__ == "__main__":
#     #print(Processing.encode_key(31))
#     with codecs.open("./data.txt","r")as fp:
#         data = fp.read()
#         fp.close()
#     print(circle.encode(Processing.encode_key(31)[0],data))
if __name__ == "__main__":
    # KEY_list = Processing.encode_key(8)
    # K = KEY_list[0]
    # K1 = KEY_list[1]
    # K2 = KEY_list[2]
    # K_RE = Processing.decode_key(K1,K2)
    # print(K,K_RE,K == K_RE)
    # D1 = '123456'
    # K1 = 'asdfghjkl'
    # NK1 = 'qwertyuiop'
    # E_D1 = AES_code.AES_encrypt(D1,K1)
    # RE_D1 = AES_code.AES_decrypt(E_D1,NK1)
    # print(D1,K1,E_D1,RE_D1)
    print(ord('1'))
    print(circle.encode('a','1'))
    #print(circle.decode('a',['149'],0,35))

• 你可以参考下这个问题的回答, 看看是否对你有帮助, 链接: https://ask.csdn.net/questions/7577470
• 我还给你找了一篇非常好的博客，你可以看看是否有帮助，链接：设计一个三维向量类，并实现向量的加法、减法以及向量与标量的乘法和除法运算。
• 除此之外, 这篇博客: 为什么要对数值类型的特征做归一化，树形算法为啥不需要归一化？中的 实验对比说明结论：  部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• 

  • 对于Lasso模型，使用MaxAbsScaler方式时，MSE增大十分明显，且归一化后结果高于不进行归一化时（可能是数据的问题），
  • 对于Redige模型，归一化结果也明显高于不归一化时的结果。
  • 对于SVR模型，不进行归一化时，其MSE会非常大，是因为svm实质上选择的是分割两类数据最远的超平面，由于错分类造成了影响，不进行归一化会造成对平面的影响，导致得到的划分平面不准确测试集成功率低。
  • 对于RandomForest和XGBoost来说，是否进行归一化对结果影响不大。这也是树模型的一大特征。
• 您还可以看一下 孙玖祥老师的图解数据结构与算法课程中的 操作最后一个元素复杂度震荡问题的解决小节, 巩固相关知识点
  
• 以下回答由chatgpt基于相关博客总结生成:

  在问题中，提到了一个自研加密算法的解密问题。然而，根据给定的参考资料，我们无法得知这种加密算法的具体细节和特性。没有具体的算法细节和实现，我们无法提供解密方法和代码。因此，对于这个问题，我无法提供解决方案。