不含盐的Fernet加密算法的替代方法

如何解决不含盐的Fernet加密算法的替代方法

嗨，我是加密算法的新手，对术语以及在哪种情况下选择什么感到困惑。现在，我不需要最安全的算法，但是它应该具有以下属性：

• 共享密钥，用于加密/解密消息（两种方式）。
• 如果使用了相同的加密文本，则密码应该相同。

我在Python中使用了Fernet算法，但是密文总是不同的。因此不适合我的需求。是否有类似于Fernet但没有Salt的算法？

解决方法

假设您正在使用cryptography模块（应该使用）：而不是使用generate_key()，请构建密钥并将其传递给Fernet构造函数。

检查此链接以获取确切的示例：https://cryptography.io/en/latest/fernet/#using-passwords-with-fernet

另外，请检查https://www.crypto101.io/（如果尚未安装）。

,

实际上，没有现成的算法可以完成您所要求的“至少知道我所知道的”。 但是在过去，我用python编写了一个带有真实服务器和真实客户端的GUI聊天室。 而且我已经写了一个基本的加密/解密算法来传递数据加密的“类似消息”。 您可以使用它，如果您想要的话，因为我从未使用过我只是出于娱乐目的而制作的服务器；）。

算法：

from cryptography.fernet import Fernet

CODES_KEY = b'LYsrKDiTRNJDm3g_h25GW0uyUzPTk8l8G02hcPM_d_U='

def encryption(msg):
    '''
    Encryption Func
    '''

    class RSA:
        '''
        RSA Encryption Func
        '''
        def __init__(self):
            self.e = self.d = self.p = self.q = self.phi = 0

        def __egcd(self,a,b):
            if a == 0:
                return (b,1)
            g,y,x = self.__egcd(b % a,a)
            return (g,x - (b // a) * y,y)

        def __modinv(self,m):
            g,x,_ = self.__egcd(a,m)
            if g != 1:
                raise Exception('modular inverse does not exist')
            return x % m

        def encrypt(self,m,key_pair=None):
            '''
            Encrypting Func
            '''
            if key_pair is None:
                key_pair[0] = self.e
                key_pair[1] = self.n

            return pow(m,key_pair[0],key_pair[1])

        def generate_keys(self,p,q,e=3):
            '''
            Generating Keys Func
            '''
            self.p = p
            self.q = q

            self.n = self.p * self.q
            self.phi = (self.p - 1) * (self.q - 1)
            self.e = e
            self.d = self.__modinv(self.e,self.phi)

            if self.phi % self.e == 0:
                raise Exception('invalid values for p and q')

        def get_public_key(self):
            '''
            Getting PublicKey Func
            '''
            return self.e,self.n

    rsa = RSA()
    # Two 1024-bit primes
    rsa.generate_keys(17055899557196527525682810191339089909014331959812898993437334555169285087976951946809555356817674844913188193949144165887100694620944167618997411049745043243260854998720061941490491091205087788373487296637817044103762239946752241631032791287021875863785226376406279424552454153388492970310795447866569138481,171994050316145327367864378293770397343246561147593187377005295591120640129800725892235968688434055779668692095961697434700708550594137135605048681344218643671046905252163983827396726536078773766353616572531688390937410451433665914394068509329532352022301339189851111636176939179510955519440490431177444857017)

    int_message = []

    for i in msg:

        int_message.append(ord(i))

    codes = []

    for i in int_message:

        codes.append(len(str(i)))

    message = int(''.join([str(x) for x in int_message]))

    # Encrypting
    encrypted_message = rsa.encrypt(message,key_pair=rsa.get_public_key())

    f = Fernet(CODES_KEY)
    encrypted_codes = f.encrypt(str(codes).encode())

    return encrypted_message,encrypted_codes

def decryption(msg,codes):
    '''
    Decryption Func
    '''

    class RSA:
        '''
        RSA Decryption Func
        '''
        def __init__(self):
            self.e = self.d = self.p = self.q = self.phi = 0

        def __egcd(self,m)
            if g != 1:
                raise Exception('modular inverse does not exist')
            return x % m

        def decrypt(self,c,key_pair=None):
            '''
            Decrypting Func
            '''
            if key_pair is None:
                key_pair[0] = self.d
                key_pair[1] = self.n

            return pow(c,self.phi)

            if self.phi % self.e == 0:
                raise Exception('invalid values for p and q')

        def get_private_key(self):
            '''
            Getting Private Key Func
            '''
            return self.d,171994050316145327367864378293770397343246561147593187377005295591120640129800725892235968688434055779668692095961697434700708550594137135605048681344218643671046905252163983827396726536078773766353616572531688390937410451433665914394068509329532352022301339189851111636176939179510955519440490431177444857017)

    # Decrypting
    f = Fernet(CODES_KEY)
    # set_trace()
    decrypted_message = str(rsa.decrypt(int(msg),key_pair=rsa.get_private_key()))
    decrypted_codes = f.decrypt(codes).decode()

    decrypted_message = list(decrypted_message)

    original_codes = []

    for i in decrypted_codes:

        if i not in ['[',']',',' ']:
            original_codes.append(int(i))

    original_message = ""

    for _,value in enumerate(original_codes):

        handler = ""
        for i in decrypted_message[:value]:
            handler += i

        original_message += chr(int(handler))
        decrypted_message = decrypted_message[value:]

    return original_message

def main():

    message = "Hi,This is a secret message"
    encrypted_message,encrypted_codes = encryption(message)
    decrypted_message = decryption(encrypted_message,encrypted_codes)
    print(decrypted_message)

if __name__ == '__main__':
    main()

对不起，如果是一团糟，但我才17岁，兄弟：)！ 也许您可以进一步优化它，我刚接触python时就已经写了。 您始终可以通过在python中运行它来生成新的“ CODES_KEY”：

from cryptography.fernet import Fernet
f = Fernet
print(f.generate_key())

编辑：我将其编写为RSA，但随后更改了代码，这就是为什么将其命名为RSA而不是：）