Merge pull request #13 from Morgan-Phoenix/fixes

All Fixes

Author: metamorphic-spyware

enrocrypt/basic.py

@@ -1,7 +1,8 @@
-from enrocrypt import error
 import uuid, os
+from enrocrypt import error
 
 class Basic():
+    '''This Class Consists of all the basic functions that can be useful'''
     def __str__(self) -> str:
         return "This Class Has All the Basic Functions Of EnroCrypt"
     def seperator(self,data: str):
@@ -47,7 +48,7 @@ def to_str(self,data):
             in_ascii.append(int(in_int[i],16))
         for i,_ in enumerate(in_ascii):
             in_str.append(chr(in_ascii[i]))
-        return(in_str)
+        return in_str
 
     def Sign(self,sign:str):
         '''A Hint Of Upcomming Updates'''

enrocrypt/core.py

@@ -14,6 +14,7 @@ class Core(Hashing,Encryption,Basic):
     def __init__(self) -> None:
         self.salt = ''
     def set_config(self,*args: Any):
+        '''Sets The Configuration For This Class And All Other Classes'''
         configs = (args[0]['configs']['salt_file'])
         value = self.__Set_Salt(configs)
         return value
@@ -30,6 +31,7 @@ def __Set_Salt(self,salt:list):
         else:
             return False
     def get_hash_object(self):
+        '''Returns A Hashing Class Object That Is Pre-Configured To Use Custom Salt If Any'''
         hashing = Hashing()
         hashing(bytes(self.salt.encode()))
         return hashing

enrocrypt/error.py

@@ -2,20 +2,25 @@ class ModifiedError(Exception):
     def __init__(self):
         self.msg = 'The List Provided To The Function Is Modified'
         super().__init__(self.msg)
+        exit()
 class ListIndexError(Exception):
     def __init__(self):
         self.msg = 'Returned List Must Only Have 4 Elements'
         super().__init__(self.msg)
+        exit()
 class NoKeyFile(Exception):
     def __init__(self):
         self.msg = 'No Path For The Key File was Provided'
         super().__init__(self.msg)
+        exit()
 class List(Exception):
- def __init__(self):
-     self.msg = "Must Be A List"
-     super().__init__(self.msg)
+    def __init__(self):
+        self.msg = "Must Be A List"
+        super().__init__(self.msg)
+        exit()
 class KeyError(Exception):
     def __init__(self,bits:int) -> None:
         self.bits = bits
         self.msg = f"Key Must Be Of 32, 24 or 16 bits not {self.bits} bits"
-        super().__init__(self.msg)
+        super().__init__(self.msg)
+        exit()

enrocrypt/hashing.py

@@ -1,6 +1,6 @@
-import hashlib, base64, uuid
+import hashlib, base64, uuid, passlib
 from cryptography.hazmat.primitives import hashes
-from typing import Any, final
+from typing import Any
 class Hashing():
     def __init__(self) -> None:
         self.salt = None
@@ -9,26 +9,6 @@ def __call__(self, *args:Any):
     def __str__(self) -> str:
         return "Hashing Funcitions In Here"
 
-    def Standard_Multi_Hash(self,Data:str):
-        '''Inreversable Salted Hash Function Don't Use If U Want To Get The Content Back'''
-        a = hashlib.sha256(); a.update(bytes(Data.encode())); b = []
-        base = hashlib.sha512()
-        md = hashlib.md5()
-        b.append(str(a.digest()).split("'")[1])
-        b[0] = str(base64.urlsafe_b64encode(bytes(b[0].encode()))).split("'")[1]
-        base.update(bytes(b[0].encode()))
-        md.update(base.digest())
-        b[0]=str(base64.urlsafe_b64encode(base64.standard_b64encode(md.digest()))).split("'")[1]
-        salt = ['H', 'c', 'D', 'L', 'b', 'M', 'S', 'a', 'N', 'q', 'K', 'j', 'V', 'd', 'O', 'W', 'x']
-        c = (b[0].split("G"))or(b[0].split("g"))or(b[0].split("v"))or(b[0].split("x")); d=[]; e=[]
-        for i in range(len(c)): a = salt[i]; b = c[i]; c[i] = b+a
-        for i in range(len(c)):
-            try: d.append(c[i+1])
-            except: d.append(c[0])
-            e.append(''.join(d))
-            final = self.BLAKE2(bytes(str(e[0]).encode()))
-            return(final)
-
     def __Salt(self,data,salt:bytes = None):
         if not salt:
             salts = []
@@ -50,29 +30,45 @@ def __Salt(self,data,salt:bytes = None):
             salts.append(str(data).split("'")[1])
             salts.append(str(hashlib.sha256(salt).digest()).split("'")[1])
             return base64.standard_b64encode(bytes((str(base64.urlsafe_b64encode(bytes(''.join(salts).encode()))).split("'")[1]+str(base64.urlsafe_b64encode(base64.standard_b64encode((bytes(''.join(salts).encode()))))).split("'")[1]).encode()))
+
+    def Standard_Multi_Hash(self,Data:str):
+        '''Inreversable Salted Hash Function Don't Use If U Want To Get The Content Back'''
+        a = hashlib.sha256(); a.update(bytes(Data.encode())); b = []
+        base = hashlib.sha512()
+        md = hashlib.md5()
+        b.append(str(a.digest()).split("'")[1])
+        b[0] = str(base64.urlsafe_b64encode(bytes(b[0].encode()))).split("'")[1]
+        base.update(bytes(b[0].encode()))
+        md.update(base.digest())
+        b[0]=str(base64.urlsafe_b64encode(base64.standard_b64encode(md.digest()))).split("'")[1]
+        salt = ['H', 'c', 'D', 'L', 'b', 'M', 'S', 'a', 'N', 'q', 'K', 'j', 'V', 'd', 'O', 'W', 'x']
+        c = (b[0].split("G"))or(b[0].split("g"))or(b[0].split("v"))or(b[0].split("x")); d=[]
+        d[0] = self.__Salt(c,salt=self.salt)
+        final = self.BLAKE2(bytes(str(d[0]).encode()))
+        return(final)
 
     def SHA256(self,data:str):
         sha = hashlib.sha256(bytes(data.encode()))
-        hash = sha.digest()
-        return self.__Salt(hash,salt=self.salt)
+        Hash = sha.digest()
+        return self.__Salt(Hash,salt=self.salt)
 
     def SHA512(self,data:str):
         sha = hashlib.sha512(bytes(data.encode()))
-        hash = str(sha.digest())
-        return self.__Salt(hash,salt=self.salt)
+        Hash = str(sha.digest())
+        return self.__Salt(Hash,salt=self.salt)
 
     def SHA244(self,data:str):
         sha = hashlib.sha224(bytes(data.encode()))
-        hash = str(sha.digest())
-        return self.__Salt(hash,salt=self.salt)
-
+        Hash = str(sha.digest())
+        return self.__Salt(Hash,salt=self.salt)
+      
     def SHA384(self,data:str):
         sha = hashlib.sha384(bytes(data.encode()))
-        hash = str(sha.digest())
-        return self.__Salt(hash,salt=self.salt)
+        Hash = str(sha.digest())
+        return self.__Salt(Hash,salt=self.salt)
 
     def BLAKE2(self,data:bytes):
         a = hashes.Hash(hashes.BLAKE2s(32))
         a.update(data)
         return self.__Salt(a.finalize(),salt=self.salt)
-        
+

enrocrypt/key.py

@@ -1,7 +1,6 @@
 from cryptography.hazmat.primitives.hashes import SHA256
 from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 from enrocrypt.hashing import Hashing
-from enrocrypt.encryption import Encryption
 from enrocrypt.error import KeyError
 
 def generate_key(words:str,salt:bytes,bits:int = 32):

setup.py

@@ -4,7 +4,6 @@
     name="enrocrypt",
     version="1.1.4",
     author="Morgan-Phoenix",
-    author_email="[email protected]",
     description="This is a Python Module For Encryption, Hashing And Other stuff",
     long_description=file,
     long_description_content_type="text/markdown",
@@ -18,6 +17,6 @@
         "Operating System :: OS Independent",
     ],
     packages=find_packages(),
-    install_requires=['cryptography'],
+    install_requires=['cryptography', 'passlib'],
     python_requires=">=3.6",
 )