DE-Lib 0.0.20__py3-none-any.whl

DE_Lib/Utils/Cipher/Cipher.py

@@ -0,0 +1,300 @@
+import os
+#from operator import truediv
+# -----------------------------------
+from Crypto.Cipher import AES, PKCS1_OAEP
+from Crypto.PublicKey import RSA
+# -----------------------------------
+from Crypto.Util.Padding import pad, unpad
+from Crypto.Random import get_random_bytes
+import base64
+import rsa
+from argon2 import PasswordHasher
+
+KEYS_RSA = rsa.newkeys(512)
+
+class RSA_Cipher:
+    """
+    Esta classe faz criptografia de pequenos textos
+    """
+    def __init__(self):
+        self.__private_key = None
+        self.__public_key = None
+        self.__path_keys = ""
+
+    def setInit(self, path, word:str=""):
+            msg, result = None, True
+            try:
+                self.setPathKeys(path)
+                self.setWord(word)
+                self.__private_key = self.getFileKey(os.path.join(self.PATH_KEYS, "private.pem"))
+                self.__public_key = self.getFileKey(os.path.join(self.PATH_KEYS, "public.pem"))
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    def CIPHER(self, word, action: str = "E"):
+            msg, result = None, True
+            try:
+                if action == "E":
+                    result = self.encrypt(word, self.PUBLIC_KEY)
+                else:
+                    result = self.decrypt(word, self.PRIVATE_KEY)
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    def encrypt(self, word, key):
+            msg, result = None, True
+            try:
+                __cifra = PKCS1_OAEP.new(key)
+                result = __cifra.encrypt(word.encode())
+                result = result.hex()
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    def decrypt(self, word, key):
+            msg, result = None, True
+            try:
+                __decifra = PKCS1_OAEP.new(key)
+                result = __decifra.decrypt(bytes.fromhex(word))
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    def getChavePublica(self):
+        msg, result = None, True
+        try:
+            self.__public_key = self.PRIVATE_KEY.publickey()
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    def getChavePrivada(self, value_bytes: int = 2048):
+        msg, result = None, True
+        try:
+            self.__private_key = RSA.generate(value_bytes)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    def setFileKey(self, key: hex, filename: str = "private.pem"):
+        msg, result = None, True
+        try:
+            with open(filename, "wb") as f:
+                f.write(key.export_key())
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    def getFileKey(self, filename):
+        msg, result = None, True
+        try:
+            x = os.getcwd()
+            with open(filename, "r") as f:
+                result = RSA.import_key(f.read())
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    def setPathKeys(self, path:str):
+            msg, result = None, True
+            try:
+                self.__path_keys = path
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    def setWord(self, word):
+            msg, result = None, True
+            try:
+                self.__word = word
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    @property
+    def PRIVATE_KEY(self):
+        return self.__private_key
+
+    @property
+    def PUBLIC_KEY(self):
+        return self.__public_key
+
+    @property
+    def PATH_KEYS(self):
+        return self.__path_keys
+
+    @property
+    def WORD(self):
+        return self.__word
+
+class AES_Cipher:
+    """
+    Esta classe faz criptografia de textos longos
+    """
+    def __init__(self):
+        ...
+
+    def encrypt(self, plaintext: str, rsa_public_key):
+        msg, result = None, True
+        try:
+            # Gerar uma chave AES aleatória (16 bytes)
+            aes_key = get_random_bytes(16)
+
+            # Criar cifra AES em modo CBC
+            cipher_aes = AES.new(aes_key, AES.MODE_CBC)
+            iv = cipher_aes.iv  # Vetor de Inicialização
+
+            # Adicionar padding ao texto para que seja múltiplo de 16
+            ciphertext = cipher_aes.encrypt(pad(plaintext.encode(), AES.block_size))
+
+            # Criptografar a chave AES com RSA
+            cipher_rsa = PKCS1_OAEP.new(rsa_public_key)
+            encrypted_aes_key = cipher_rsa.encrypt(aes_key)
+            result = base64.b64encode(encrypted_aes_key + iv + ciphertext).decode()
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+
+    def decrypt(self, encrypted_data: str, rsa_private_key):
+        msg, result = None, True
+        try:
+            # Converter de base64 para bytes
+            encrypted_data = base64.b64decode(encrypted_data)
+
+            # Extrair partes (chave AES criptografada + IV + texto criptografado)
+            key_size = rsa_private_key.size_in_bytes()
+            encrypted_aes_key = encrypted_data[:key_size]
+            iv = encrypted_data[key_size:key_size + 16]
+            ciphertext = encrypted_data[key_size + 16:]
+
+            # Descriptografar a chave AES com RSA
+            cipher_rsa = PKCS1_OAEP.new(rsa_private_key)
+            aes_key = cipher_rsa.decrypt(encrypted_aes_key)
+
+            # Descriptografar o texto com AES
+            cipher_aes = AES.new(aes_key, AES.MODE_CBC, iv)
+            plaintext = unpad(cipher_aes.decrypt(ciphertext), AES.block_size)
+
+            result = plaintext.decode()
+
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+class B64_Cipher:
+    def __init__(self):
+        ...
+
+    @staticmethod
+    def base64_encrypt(word: str, encode_pattern: str = "utf-8"):
+        encoded = (base64.b64encode(word.encode(encode_pattern)))
+        encoded_ascii = encoded.decode(encode_pattern)
+        return encoded_ascii
+
+    @staticmethod
+    def base64_decrypt(word: str, encode_pattern: str = "utf-8"):
+        try:
+            word = word.encode(encode_pattern)
+            decoded = base64.b64decode(word).decode(encode_pattern)
+            # decoded_ascii = decoded.decode()
+        except Exception as error:
+            decoded = error
+        finally:
+            return decoded
+
+    @staticmethod
+    def token_get() -> str:
+        # key = Fernet.generate_key()
+        # cipher_suite = Fernet(key)
+        cipher_suite = True
+        # return key.decode("ascii")
+        return cipher_suite
+
+    @staticmethod
+    def CRYPTOGRAPHY(word: str, token: str = None, action: str = "E"):
+        msg, result = None, None
+        try:
+            if action == "E":
+                if isinstance(word, str):
+                    word = word.encode()
+                result = token.encrypt(word).decode()
+            else:
+                if isinstance(word, str):
+                    word = word.encode()
+                result = token.decrypt(word).decode()
+        except Exception as error:
+            msg = error.args[0]
+            result = msg
+        finally:
+            return result
+
+class ARGON:
+    # ----------------------------------
+    def __init__(self):
+        msg, result = None, True
+        try:
+            self.__ph = PasswordHasher()
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    @staticmethod
+    # ----------------------------------
+    def hash(self, value):
+        msg, result = None, True
+        try:
+            result = self.HASH.hash(value)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    @staticmethod
+    # ----------------------------------
+    def unHash(self, value, key):
+        msg, result = None, True
+        try:
+            result = self.HASH.verify(key, value)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    @property
+    def HASH(self):
+        return self.__ph
+
+
+
+

DE_Lib/Utils/Cipher/Fernet.py

@@ -0,0 +1,81 @@
+from cryptography.fernet import Fernet
+import os
+import json
+
+class FERNET:
+    def __init__(self):
+        self.__token = None
+        self.__cipher = None
+
+    # -----------------------------------
+    def encrypt(self, word:str, token: str):
+        msg, result = None, None
+        try:
+            #x = Fernet(key)
+            result = self.CIPHER.encrypt(word.encode())
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    # ----------------------------------
+    def decrypt(self, word):
+        msg, result = None, True
+        try:
+            result = self.CIPHER.decrypt(word).decode()
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+
+    # ----------------------------------
+    def setBuildToken(self):
+        # normalmente sera gerado apenas uma unica vez
+        # armazenar a chave. Caso seja gerado uma outra
+        # todas as criptografias geraradas anteriormente
+        # serao perdidas.
+        msg, result = None, True
+        try:
+            self.__token = Fernet.generate_key()
+            result = self.TOKEN
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    # ----------------------------------
+    def setToken(self, token):
+        msg, result = None, True
+        try:
+            self.__token = token
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+
+    # ----------------------------------
+    def __setCipher(self, key):
+        msg, result = None, True
+        try:
+            self.__cipher = Fernet(key)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+
+    @property
+    def TOKEN(self) -> str:
+        return self.__token
+
+    @property
+    def CIPHER(self):
+        return Fernet(self.TOKEN)
+

DE_Lib/Utils/Cipher/Gcm.py

@@ -0,0 +1,78 @@
+# criptografia funcionou normalmente
+# tem que utulizar a biblioteca "pip install cryptography==41.0.7"
+
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives import hashes
+import os
+import base64
+
+from docutils.io import error_string
+
+
+class GCM:
+    def __init__(self):
+        ...
+
+    def __buildKey(self, token: str, salt: bytes) -> bytes:
+        msg, result = None, None
+        try:
+            result = PBKDF2HMAC(algorithm=hashes.SHA256(),
+                                length=32,
+                                salt=salt,
+                                iterations=100000
+                                )
+            result = result.derive(token.encode())
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    # ----------------------------------
+    def Encrypt(self, token:str, word:str):
+        msg, result = None, True
+        try:
+            salt = os.urandom(16)
+            key = self.__buildKey(token=token, salt=salt)
+
+            iv = os.urandom(12)
+            cipher = Cipher(algorithms.AES(key), modes.GCM(iv))
+            encryptor = cipher.encryptor()
+
+            text_bytes = word.encode()
+            text_cryptography = encryptor.update(text_bytes) + encryptor.finalize()
+            result = base64.b64encode(salt + iv + encryptor.tag + text_cryptography).decode()
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    # ----------------------------------
+    def Decrypt(self, word:str, token: str):
+        msg, result = None, True
+        try:
+            data = base64.b64decode(word)
+
+
+            salt = data[:16]
+            iv = data[16:28]
+            tag = data[28:44]
+            __text = data[44:]
+
+            key = self.__buildKey(token, salt)
+            cipher = Cipher(algorithms.AES(key), modes.GCM(iv, tag))
+            decryptor = cipher.decryptor()
+            result = decryptor.update(__text) + decryptor.finalize()
+
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result.decode("utf-8")
+
+
+
+
+

DE_Lib/Utils/Cipher/Pbkdf2.py

@@ -0,0 +1,43 @@
+import hashlib
+import os
+
+class PBKDF2:
+    # ----------------------------------
+    def __init__(self):
+        msg, result = None, True
+        try:
+            self.__saltAleatorio = 16
+        except Exception as error:
+            msg = error
+            result = msg
+
+    # ----------------------------------
+    def hash(self, value, salt=None):
+        msg, result = None, True
+        try:
+            if salt is None:
+                salt = os.urandom(self.SALT)
+            hash_value = hashlib.pbkdf2_hmac("sha256", value.encode(), salt, 100000)
+            result = salt + hash_value
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    # ----------------------------------
+    def validHash(self, value, key):
+        msg, result = None, True
+        try:
+            salt = key[:self.SALT]
+            new_hash = self.hash(value, salt)
+            result = (new_hash == key)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    @property
+    def SALT(self):
+        return self.__saltAleatorio

DE_Lib/Utils/Cipher/Rsa.py

@@ -0,0 +1,140 @@
+from Crypto.PublicKey import RSA
+from Crypto.Cipher import PKCS1_OAEP
+import os
+
+class RSA_Cipher:
+    """
+    Esta classe faz criptografia de pequenos textos
+    """
+    def __init__(self):
+        self.__private_key = None
+        self.__public_key = None
+        self.__path_keys = ""
+
+    def setInit(self, path, word:str=""):
+            msg, result = None, True
+            try:
+                self.setPathKeys(path)
+                self.setWord(word)
+                self.__private_key = self.getFileKey(os.path.join(self.PATH_KEYS, "private.pem"))
+                self.__public_key = self.getFileKey(os.path.join(self.PATH_KEYS, "public.pem"))
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    def CIPHER(self, word, action: str = "E"):
+            msg, result = None, True
+            try:
+                if action == "E":
+                    result = self.encrypt(word, self.PUBLIC_KEY)
+                else:
+                    result = self.decrypt(word, self.PRIVATE_KEY)
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    def encrypt(self, word, key):
+            msg, result = None, True
+            try:
+                __cifra = PKCS1_OAEP.new(key)
+                result = __cifra.encrypt(word.encode())
+                result = result.hex()
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    def decrypt(self, word, key):
+            msg, result = None, True
+            try:
+                __decifra = PKCS1_OAEP.new(key)
+                result = __decifra.decrypt(bytes.fromhex(word))
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    def getChavePublica(self):
+        msg, result = None, True
+        try:
+            self.__public_key = self.PRIVATE_KEY.publickey()
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    def getChavePrivada(self, value_bytes=2048):
+        msg, result = None, True
+        try:
+            self.__private_key = RSA.generate(2048)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    def setFileKey(self, key: hex, filename: str = "private.pem"):
+        msg, result = None, True
+        try:
+            with open(filename, "wb") as f:
+                f.write(key.export_key())
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    def getFileKey(self, filename):
+        msg, result = None, True
+        try:
+            x = os.getcwd()
+            with open(filename, "r") as f:
+                result = RSA.import_key(f.read())
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    def setPathKeys(self, path:str):
+            msg, result = None, True
+            try:
+                self.__path_keys = path
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    def setWord(self, word):
+            msg, result = None, True
+            try:
+                self.__word = word
+            except Exception as error:
+                msg = error
+                result = msg
+            finally:
+                return result
+
+    @property
+    def PRIVATE_KEY(self):
+        return self.__private_key
+
+    @property
+    def PUBLIC_KEY(self):
+        return self.__public_key
+
+    @property
+    def PATH_KEYS(self):
+        return self.__path_keys
+
+    @property
+    def WORD(self):
+        return self.__word