remove jwt

src/aes_encrypt.py

@@ -10,48 +10,48 @@ __module_name__ = "aes_encrypt"
 __version__text__ = "1"
 
 import base64
-import json
+import pickle
 
 from Crypto.Cipher import AES
 
 from fred import flaskred
-from schemas import UserSchema
 
 
 class AESCrypto:
-    def __init__(self, encoded_secret_key: str, padding_character: bytes = 'a'.encode('UFT-8')):
+    def __init__(self, encoded_secret_key: str, padding_character: bytes = '{'.encode('ascii')):
         self.padding_character = padding_character
         self.encoded_secret_key = encoded_secret_key
 
-    def encrypt_message(self, private_msg) -> bytes:
+    def encrypt_message(self, private_msg: str) -> tuple:
         secret_key = base64.b64decode(self.encoded_secret_key)
         cipher = AES.new(secret_key, AES.MODE_EAX)
-        padded_private_msg = private_msg + (self.padding_character.decode('UFT-8') * ((16 - len(private_msg)) % 16))
-        encrypted_msg = cipher.encrypt(padded_private_msg)
-        encoded_encrypted_msg = base64.b64encode(encrypted_msg)
-        return encoded_encrypted_msg
+        ciphertext, tag = cipher.encrypt_and_digest(private_msg.encode('UTF-8'))
+        return cipher.nonce, ciphertext, tag
 
-    def decrypt_message(self, encoded_encrypted_msg) -> str:
+    def decrypt_message(self, nonce: bytes, encoded_encrypted_msg: bytes, tag: bytes) -> str:
         secret_key = base64.b64decode(self.encoded_secret_key)
-        encrypted_msg = base64.b64decode(encoded_encrypted_msg)
-        cipher = AES.new(secret_key, AES.MODE_EAX)
-        decrypted_msg = cipher.decrypt(encrypted_msg)
-        unpadded_private_msg = decrypted_msg.rstrip(self.padding_character)
-        return unpadded_private_msg.decode('UTF-8')
+        cipher = AES.new(secret_key, AES.MODE_EAX, nonce)
+        msg = cipher.decrypt_and_verify(encoded_encrypted_msg, tag).decode('UTF-8')
+        return msg
 
 
 class EncryptedUserRedis:
+
     def __init__(self, encoded_secret_key: str):
         self.aes = AESCrypto(encoded_secret_key)
-        self.userschema = UserSchema(many=False)
 
-    def store(self, user: UserSchema) -> None:
-        plaindict = self.userschema.dump(user)
-        plaindict['password'] = self.aes.encrypt_message(user['password'])
-        flaskred.set(user['name'], json.dumps(plaindict).encode('UTF-8'))
+    def store(self, user: dict) -> None:
+        nonce, ciphertext, tag = self.aes.encrypt_message(user['password'])
+        user['nonce'] = nonce
+        user['ciphertext'] = ciphertext
+        user['tag'] = tag
+        user.pop('password', None)
+        flaskred.set(user['name'], pickle.dumps(user))
 
-    def load(self, username: str) -> UserSchema:
-        encryptedstr = flaskred.get(username).decode('UTF-8')
-        encrypteddict = json.loads(encryptedstr)
-        user = UserSchema(name=encrypteddict['name'], password=self.aes.decrypt_message(encrypteddict['password']))
-        return user
+    def load(self, username: str) -> dict:
+        encrypteddict = pickle.loads(flaskred.get(username))
+
+        plaindict = {"name": encrypteddict['name'],
+                     "password": self.aes.decrypt_message(encrypteddict['nonce'], encrypteddict['ciphertext'],
+                                                          encrypteddict['tag'])}
+        return plaindict