.

Author: Grc Algoritmos

.DS_Store

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Renne
+Copyright (c) 2021 Renne C. (GRC Algoritmos)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LICENSE LICENSE.txtLICENSE renamed to LICENSE.txt

@@ -1,49 +1,79 @@
-import crypter
 import ast
 import json
-
+from os.path import exists
+from .crypter import (encrypt256, encrypt, encode64,
+                      decrypt, decode64,
+                      get_content, get_sequence5, get_sequence6, get_string,
+                      open_file)
 
 class Encrypt:
 
     def encryptjson(decrypted_string, password="", sha256=True):
         if sha256:
-            password = crypter.encrypt256(password)
+            password = encrypt256(password)
         # RETURN AS A STRING
-        return crypter.encrypt(decrypted_string, password)
+        return encrypt(decrypted_string, password)
 
-    def jsonfile(filename, password="", sha256=True, save_file=False, output="json"):
-        json_crypt_document = Encrypt.encryptjson(crypter.open_file(filename), password, sha256)
+    def jsonfile(filename, password="", sha256=True, save_file=False):
+        try:
+            json_crypt_document = Encrypt.encryptjson(open_file(filename), password=password, sha256=sha256)
+        except:
+            return None
         if save_file:
             # SAVE INTO FILE AND RETURN A BOOLEAN TRUE
-            with open(filename, "w", encoding="utf-8") as json_file_encrypted :
-                json_file_encrypted.write(json_crypt_document)
-            return True
+            try:
+                with open(filename, "w", encoding="utf-8") as json_file_encrypted :
+                    json_file_encrypted.write(json_crypt_document)
+                return True
+            except:
+                return False
         else:
-            if output == "json":
-                # RETURN AS A DICTIONARY
-                return json.loads(json_crypt_document)
+            # RETURN AS A STRING
+            return json_crypt_document
+
+    def jsonstring(string_to_encrypt, password="", sha256=True, save_file=False, filename=None, overwrite=False):
+        if save_file and filename is not None:
+            if not exists(filename) or exists(filename) and overwrite:
+                try:
+                    with open(filename, "w", encoding="utf-8") as string_encrypted:
+                        string_encrypted.write(Encrypt.encryptjson(string_to_encrypt, password=password, sha256=sha256))
+                    return True
+                except:
+                    return False
             else:
-                # RETURN AS A STRING
-                return json_crypt_document
+                return False
+        else:
+            return Encrypt.encryptjson(string_to_encrypt, password=password, sha256=sha256)
 
-    def jsonstring(string_to_encrypt, password="", sha256=True):
-        return Encrypt.encryptjson(string_to_encrypt, password, sha256)
+    def dictionary(dictionary_to_encrypt, password="", sha256=True, save_file=False, filename=None, overwrite=False):
+        if save_file and filename is not None:
+            if not exists(filename) or exists(filename) and overwrite:
+                try:
+                    with open(filename, "w", encoding="utf-8") as dictionary_encrypted:
+                        dictionary_encrypted.write(Encrypt.encryptjson(str(dictionary_to_encrypt), password=password, sha256=sha256))
+                    return True
+                except:
+                    return False
+            else:
+                return False
+        else:
+            return Encrypt.encryptjson(str(dictionary_to_encrypt), password=password, sha256=sha256)
 
 
 class Decrypt:
 
     def decryptjson(encrypted_document, password="", sha256=True, ignore_verification=False, indent=4):
         try:
-            original_document_hash = crypter.encrypt256(encrypted_document[0])
+            original_document_hash = encrypt256(encrypted_document[0])
             if sha256:
-                password = crypter.encrypt256(password)
+                password = encrypt256(password)
             # CHECK IF FILE IS ENCRYPTED OR IF WAS MODIFIED
             if encrypted_document[6] == original_document_hash or ignore_verification:
-                crypt_key1 = crypter.get_sequence5(0, 5, password, encrypted_document[1])
-                crypt_key2 = crypter.get_sequence5(5, 10, password, encrypted_document[2])
-                crypt_key3 = crypter.get_sequence5(10, 15, password, encrypted_document[3])
-                crypt_key4 = crypter.get_sequence5(15, 20, password, encrypted_document[4])
-                crypt_key5 = crypter.get_sequence6(20, 26, password, encrypted_document[5])
+                crypt_key1 = get_sequence5(0, 5, password, encrypted_document[1])
+                crypt_key2 = get_sequence5(5, 10, password, encrypted_document[2])
+                crypt_key3 = get_sequence5(10, 15, password, encrypted_document[3])
+                crypt_key4 = get_sequence5(15, 20, password, encrypted_document[4])
+                crypt_key5 = get_sequence6(20, 26, password, encrypted_document[5])
                 if crypt_key1 is not None and crypt_key2 is not None and \
                 crypt_key3 is not None and crypt_key4 is not None and \
                 crypt_key5 is not None:
@@ -58,8 +88,8 @@ def decryptjson(encrypted_document, password="", sha256=True, ignore_verificatio
                         crypt_content.append(key_sequence)
                     for key_sequence in crypt_key5:
                         crypt_content.append(key_sequence)
-                    decrypt = crypter.decrypt(encrypted_document[0], crypt_content)
-                    return json.dumps(ast.literal_eval(decrypt), indent=indent, ensure_ascii=False)
+                    decrypted_string = decrypt(encrypted_document[0], crypt_content)
+                    return json.dumps(ast.literal_eval(decrypted_string), indent=indent, ensure_ascii=False)
                 else:
                     return None
             else:
@@ -68,12 +98,19 @@ def decryptjson(encrypted_document, password="", sha256=True, ignore_verificatio
             return False
 
     def jsonstring(string_to_decrypt, password="", sha256=True, ignore_verification=False, indent=4):
-        encrypted_document = crypter.get_string(string_to_decrypt)
-        return Decrypt.decryptjson(encrypted_document, password, sha256, ignore_verification, indent)
+        encrypted_document = get_string(string_to_decrypt)
+        return Decrypt.decryptjson(encrypted_document, password=password, sha256=sha256,
+                                   ignore_verification=ignore_verification, indent=indent)
+
+    def dictionary(dictionary_to_decrypt, password="", sha256=True, ignore_verification=False, indent=4):
+        encrypted_document = get_string(dictionary_to_decrypt)
+        return json.loads(Decrypt.decryptjson(encrypted_document, password=password, sha256=sha256,
+                                   ignore_verification=ignore_verification, indent=indent))
 
     def jsonfile(file_to_decrypt, password="", sha256=True, ignore_verification=False, indent=4, save_file=False, output="json"):
-        encrypted_document = crypter.get_content(file_to_decrypt)
-        decrypted_string = Decrypt.decryptjson(encrypted_document, password, sha256, ignore_verification, indent)
+        encrypted_document = get_content(file_to_decrypt)
+        decrypted_string = Decrypt.decryptjson(encrypted_document, password=password, sha256=sha256,
+                                               ignore_verification=ignore_verification, indent=indent)
         if decrypted_string:
             if save_file:
                 with open(file_to_decrypt, "w", encoding="utf-8") as output_file:

__init__.py

@@ -1,35 +1,95 @@
-import jsoncrypt
+from jsoncrypt import Encrypt, Decrypt
 
-# TO ENCRYPT A JSON FILE - FOLLOW EXAMPLE
-filename = "example.json"
+# FORMULAS TO ENCRYPT AND DECRYPT
+# Encrypt.jsonfile(json_filename_to_encrypt)
+# Encrypt.jsonstring(json_string_to_encrypt)
+# Encrypt.dictionary(a_dictionary_to_encrypt)
+# Decrypt.jsonfile(filename_encrypted)
+# Decrypt.jsonstring(json_string_encrypted)
+# Decrypt.dictionary(string_of_a_dictionary_encrypted)
+# FOLLOWING SOME EXAMPLES
 
-# TO ENCRYPT AND SAVE FILE
-if jsoncrypt.Encrypt.jsonfile(filename, save_file=True):
-    with open(filename, "r") as file:
-        encrypted_json = file.read()
-        print(encrypted_json)
+# SELECT A JSON FILE
+filename = "./example.json"
 
-        print("encrypted_json type is -> {}".format(type(encrypted_json)))
-        input("Press any key to see decrypted version working with a string")
+# TO ENCRYPT FROM A FILE AND JUST GET AS A STRING WITHOUT SAVING IT
+Encrypt.jsonfile(filename)
+# IT WILL RETURN A STRING IF WAS A JSON FILE AND SUCCESS TO ENCRYPT OR
+# IT WILL RETURN A NONE IF WASN'T A JSON FILE AND FAILED TO ENCRYPT
+# FINALLY TO CATCH NOT JSON FILES USE
+string_encrypted = Encrypt.jsonfile(filename)
+if string_encrypted:
+    print("Encrypted successfully")
+    print(string_encrypted)
+else:
+    print("Not possible to encrypt non json files")
+
+# TO ENCRYPT FROM A FILE AND SAVE FILE USE
+# Encrypt.jsonfile(filename, save_file=True)
+# IT WILL RETURN BOOLEAN TRUE IF WAS SUCCESS OR BOOLEAN FALSE IF FAILED TO SAVE
+# FINALLY USE FORMULA TO CATCH NON JSON FILES OR NO PERMISSIONS TO SAVE ON DISK
+if Encrypt.jsonfile(filename, save_file=True):
+    print("File {} was successfully encrypted and has been saved!".format(filename))
+else:
+    print("Failed to encrypt file")
 
-        # TO USE DECRYPTION AS A STRING
-        decrypted_json = jsoncrypt.Decrypt.jsonstring(encrypted_json)
-        print(decrypted_json)
+# DECRYPT INTO MEMORY TO USE DATA AS NECESSARY (HERE FILE USED MUST BE ENCRYPTED TO BE ABLE TO DECRYPT RIGHT!?)
+# IF FILE IS NOT ENCRYPTED IT WILL RETURN A BOOLEAN FALSE
+# TO DECRYPT AND GET AS DICTIONARY USE
+dictionary = Decrypt.jsonfile(filename)
+# TO DECRYPT AND GET AS STRING USE
+string_decrypted = Decrypt.jsonfile(filename, output="string")
+# TO DECRYPT AND GET AS STRING AND CHANGE INDENT USE (DEFAULT INDENT IS 4)
+string_indented = Decrypt.jsonfile(filename, output="string", indent=2)
+
+# TO DECRYPT FROM A FILE AND SAVE IT
+# IT WILL RETURN BOOLEAN TRUE IF WAS SUCCESSFULLY DECRYPTED OR BOOLEAN FALSE IF FAILED TO SAVE
+# FINALLY USE FORMULA TO CATCH NON ENCRYPTED FILES OR NO PERMISSIONS TO SAVE ON DISK
+if Decrypt.jsonfile(filename, save_file=True):
+    print("File {} was successfully decrypted and has been saved!".format(filename))
 else:
-    print("Something went wrong!")
+    print("File is not encrypted or it was modified")
 
-input("Press any key to decrypt file and save it")
+# IT IS POSSIBLE ALSO TO ENCRYPT AND DECRYPT FROM A STRING
+# IMPORTANT! STRING MUST BE ON A JSON TYPE FORMAT
+my_json_string_encrypted = Encrypt.jsonfile(filename)
+print("ENCRYPTED FROM A FILE INTO A STRING")
+print(my_json_string_encrypted)
+# TO DECRYPT A STRING ON FORMAT OF JSON USE
+decrypted_jsonstring = Decrypt.jsonstring(my_json_string_encrypted)
+if decrypted_jsonstring:
+    print("DECRYPTED FROM A STRING INTO ANOTHER STRING")
+    print(decrypted_jsonstring)
+else:
+    print("String is not encrypted or not in a json format")
 
-# TO DECRYPT AND SAVE FILE
-if jsoncrypt.Decrypt.jsonfile(filename, save_file=True):
-    with open(filename, "r") as file:
-        decrypted_json = file.read()
-        print(decrypted_json)
+# IS POSSIBLE TO ENCRYPT ALSO A DICTONARY TYPE
+# ON ENCRYPT IT RETURN A STRING AND ON DECRYPT IT RETURN A DICTIONARY
+mydict = {"Name": "GRC Algoritmos"}
+encrypted_dict = Encrypt.dictionary(mydict)
+# LET's SEE:
+print("Encrypted Dictionary:")
+print(encrypted_dict)
+print(type(encrypted_dict))
+print("Decrypted Dictionary:")
+# DECRYPTED AS A DICTIONARY
+decrypted_dict = Decrypt.dictionary(encrypted_dict)
+print(decrypted_dict)
+print(type(decrypted_dict))
+# DECRYPTED AS A STRING
+decrypted_string = Decrypt.jsonstring(encrypted_dict)
+print(decrypted_string)
+print(type(decrypted_string))
 
-input("Press any key to encrypt from a file into memory")
+# IS POSSIBLE TO ENCRYPT A DICTONARY AND SAVE IN A FILE
+# IT WILL RETURN A BOOLEAN TRUE IF WAS SUCCESSFULL SAVED OR BOOLEAN FALSE IF FAILED
+# IF FILE EXISTS AS DEFAULT IT WILL RETURN FALSE BUT IS POSSIBLE TO ALLOW OVERWRITE JUST SET overwrite=True
+mydict = {"Name": "GRC Algoritmos", "File": "Saved"}
+if Encrypt.dictionary(mydict, save_file=True, filename="grc.json", overwrite=True):
+    print("Successfully saved!")
+else:
+    print("Not possible to save")
 
-# TO ENCRYPT WITHOUT SAVING IN A FILE
-print(jsoncrypt.Encrypt.jsonfile(filename, save_file=False, output="json"))
 
 # OPTIONS TO ENCRYPT AND DECRYPT A JSON FILE
 # save_file="Boolean"  -> Saves the result into the same file