def notes_cli(comando): if comando.__contains__("-v"): if not Big.notes: print(langs("p", 33)) return for i in enumerate(Big.notes): print(fg.red + str(i[0]) + fg.norm, fg.yellow + " ".join(i[1][:2]) + fg.red + " ..." + fg.norm) user = int(getinputnoerrors("N: ")) note = [] for i in enumerate(Big.notes): if user == i[0]: note = i[1] print("\n") for i in note: print(i) print("\n") return notes_cli("note -v".split()) elif comando.__contains__("-d"): if not Big.notes: print(langs("p", 33)) return for i in enumerate(Big.notes): print(fg.red + str(i[0]) + fg.norm, fg.yellow + " ".join(i[1][:2]) + fg.red + " ..." + fg.norm) user = int(getinputnoerrors("N: ")) for i in enumerate(Big.notes): if user == i[0]: Big.delnote(i[0]) Big.encrypt() else: print(langs("p", 47)) note = getinputnoerrors("", multiline=True) Big.add_note(note)
def decrypt(self, what): try: f = Fernet(self.key) decrypted = f.decrypt(what).decode("utf-8") self.encrypted = False return decrypted except ValueError: print(langs("err", 1)) self.encrypted = True except (InvalidKey, InvalidToken): print(langs("err", 2)) self.encrypted = True
def new_db(self, sub=False): if gui: if sub: self.name = "DB_" + secure_hash(3, pwd=True) + ".aesdb" self.key = Fernet.generate_key() self.dictionary = new_dictionary(default=True) self.passwords = [] self.encrypted = False self.encrypt() if fast_load: preferences(("f", True)) return winshowkey(self.key) if not sub: TEMP = BigFile(name="DB_" + secure_hash(3, pwd=True) + ".aesdb", key=Fernet.generate_key(), dictionary=new_dictionary(default=True), passwords=[], notes=[], encrypted=False) TEMP.encrypt() return winshowkey(TEMP.key.decode("utf-8")) if not gui: if sub: print(langs("p", 1)) self.name = "DB_" + secure_hash(3, pwd=True) + ".aesdb" self.key = Fernet.generate_key() self.dictionary = new_dictionary(default=True) self.passwords = [] self.notes = [] self.encrypted = False new = open(path_big_files + self.name, "w") new.write("") new.close() print(langs("p", 9)) print(fg.red + langs("p", 8) + fg.yellow + str(self.key.decode("utf-8") + fg.norm)) self.encrypt() print(langs("p", 3)) preferences(default=True) if not sub: TEMP = BigFile(name="DB_" + secure_hash(3, pwd=True) + ".aesdb", key=Fernet.generate_key(), dictionary=new_dictionary(default=True), passwords=[], notes=[], encrypted=False) print(fg.red + langs("p", 8) + fg.yellow + str(TEMP.key.decode("utf-8") + fg.norm)) TEMP.encrypt()
def search(self, key=""): if key: results = [] for pwd in self.passwords: for item, value in pwd.items(): if item == "plain_pass": value = self.fromfirstlevel(pwd["firstlevel"]) if SequenceMatcher(value, key).ratio() > 0.66 or value == key: results.append(self.passwords.index(pwd)) else: pass if not results: print(langs("p", 33)) elif len(results) > 1: print(langs("p", 34)) return results
def encrypt(self, message: bool = False): f = Fernet(self.key) encrypted_big_file = f.encrypt( str(self.Construction()).encode("utf-8")) file = open(path_big_files + self.name, "wb") file.write(encrypted_big_file) if message: print(langs("p", 7)) file.close() return fg.green + "Success" + fg.norm
def __dicts__(): print(langs("p", 3)) user = getinputnoerrors(": ") if user == "new": crc = getinputnoerrors(langs("p", 45)) len_hash = int(getinputnoerrors(langs("p", 46))) if crc.isdigit(): crc = int(crc) new = new_dictionary(len_hash, crc) else: new = new_dictionary(len_hash, custom_crc=crc) print(langs("p", 2)) name = "EncryptDict" + str(oggi) + ".dict" print(langs("p", 1) + name) user = getinputnoerrors("y/n: ") if user == "y": Big.Migration(new) elif user == "n": file = open(path_dicts + name, "w") file.write(str(new)) file.close()
def delete(self, key): results = [] for item in self.passwords: for i, v in item.items(): if i == "plain_pass": v = self.fromfirstlevel(item["firstlevel"]) if key == v: results.append(item) if len(results) > 1: print(langs("p", 39)) if getinputnoerrors("y/n : ") == "y": for item in results: self.passwords.remove(item) self.encrypt() else: pass elif len(results) == 1: self.passwords.remove(results[0]) self.encrypt() elif not results: print(langs("p", 33))
def __keys__(): print(langs("p", 18)) print(langs("p", 19)) while True: user = getinputnoerrors("comando: ") if user == "new": new_key = Fernet.generate_key() print( langs("p", 22) + fg.yellow + str(new_key.decode("utf-8")) + fg.norm) print(langs("p", 20)) user = getinputnoerrors(": ") if user == "y": Big.new_key(new_key) Big.encrypt() preferences(save=True) break elif user == "show": print(langs("p", 37)) elif user == "save": name = Big.savekey() print("Saved to: " + name) elif user == "help": m = langs("keys_help", 0) for command in m: print(fg.red + str(command[0]) + fg.norm + " : " + fg.yellow + str(command[1]) + fg.norm) else: break
def cloudupload(self): gauth = GoogleAuth() try: gauth.LoadCredentialsFile("cloud.txt") except: print(langs("err", 9)) if gauth.credentials is None: try: gauth.LocalWebserverAuth() print(langs("p", 41)) if getinputnoerrors("y/n : ") == "y": gauth.SaveCredentialsFile("cloud.txt") except InvalidConfigError: print(langs("err", 10)) drive = GoogleDrive(gauth) file1 = drive.CreateFile({'title': self.name}) file1.SetContentString( str(open(path_big_files + self.name, 'r').read())) try: file1.Upload() if gui: sg.Popup("Success", auto_close=True, auto_close_duration=2) else: print(langs("p", 38)) except InvalidConfigError: print(langs("err", 8)) print(langs("p", 42)) comando = getinputnoerrors(": ") if comando == "console": webbrowser.open( 'https://console.developers.google.com/apis/api/drive/overview' ) elif comando == "readme": sleep(8) elif comando == "guide": webbrowser.open( "https://medium.com/@annissouames99/how-to-upload-files-automatically-to-drive-with-python-ee19bb13dda" ) return
def preferences(*args, mode="auto", default=False, save=False): # ("argument",value) arguments = "f" or "g" or "l" global lang, gui, fast_load fast_load_key = "" def saveprefs(prefs): if fast_load: prefs["key"] = Big.key.decode("utf-8") Big.renamedb("fastload.aesdb") else: prefs["key"] = "" file = open(path + "preferences.json", "w") file.write(json.dumps(prefs)) print(fg.green + "saved..." + fg.norm) if default: lang = 'en' gui = False fast_load = True fast_load_key = Big.key.decode("utf-8") save = True if save: prefs = { "lang": lang, "gui": gui, "fast_load": fast_load, "key": fast_load_key } return saveprefs(prefs) if mode == "auto": for arg in args: if arg[0] == "l": lang = arg[1] elif arg[0] == "f": if arg[1]: fast_load = arg[1] else: fast_load = arg[1] elif arg[0] == "g": gui = arg[1] elif mode == "man": prefs = { "lang": lang, "gui": gui, "fast_load": fast_load, "key": fast_load_key } for item, value in prefs.items(): if item == "key": continue print(f'{item} : {value}') if item == "lang": print(langs("p", 15)) if getinputnoerrors(": ") == "y": if lang == "it": lang = "en" else: lang = "it" else: pass elif item == "gui": if gui: print(langs("p", 17)) if getinputnoerrors(": ") == "n": gui = False else: print(langs("p", 16)) if getinputnoerrors(": ") == "y": gui = True elif item == "fast_load": if fast_load: print(langs("p", 25)) if getinputnoerrors(": ") == "n": fast_load = False fast_load_key = "" else: print(langs("p", 24)) if getinputnoerrors(": ") == "y": fast_load = True fast_load_key = Big.key.decode("utf-8") return saveprefs(prefs={ "lang": lang, "gui": gui, "fast_load": fast_load, "key": fast_load_key })
def main(): global lang, gui, fast_load, fast_load_key while True: if Big.dictionary == 0: Big.charge() else: break while True: if gui: layout = [[ sg.Text("Current Database: "), sg.Text(Big.name, key="showdb", text_color="yellow", justification="right") ], [ sg.Text("Current Dictionary: ", justification="left"), sg.Text(toshow(Big.dictionary["A"], 5), justification="right", text_color="yellow", key="showdict") ], [ sg.Text("Current key: "), sg.Text(toshow(Big.key.decode("utf-8"), 5), key="showkey", text_color="yellow", justification="right") ], [sg.Text("--- DB OPERATIONS ---")], [ sg.Button("New", key="newdb"), sg.Button("Rename", key="rename"), sg.InputText(key="newname", size=(10, 1)), sg.Button("Upload", key="upload") ], [sg.Text("--- KEY OPERATIONS ---")], [ sg.Button("Copy", key="copy_key"), sg.Button("Change", key="change_key"), sg.Button("Save", key="save_key") ], [sg.Text("--- DICTIONARY OPERATIONS ---")], [ sg.Button("Visualize", key="gui_dicts"), sg.Button("Save", key="save_dict"), sg.Button("Import", key="import_dict"), sg.Button("New", key="new_dict"), sg.Checkbox("Custom Build", key="custom") ], [sg.Text("--- FIRSTLEVEL TECHNOLOGY---")], [ sg.Button("To Firstlevel", key="tofirstlevel"), sg.Button("From Firstlevel", key="fromfirstlevel") ], [sg.Text("--- PASSWORD OPERATIONS ---")], [ sg.Button("Passwords", key="PWDS_"), sg.Button("Add", key="newpwd"), sg.Button("Secure Pass", key="securepass") ], [sg.Text("--- NOTES OPERATIONS ---")], [ sg.Button("Add", key="newnote"), sg.Button("All", key="notes") ], [sg.Text("-------------")], [ sg.Button("EXIT", key="exit"), sg.Text("Preferences"), sg.Checkbox("Gui: ", default=bool(gui), key="gui", enable_events=True), sg.Checkbox("Fast-Load: ", default=bool(fast_load), key="fast_load", enable_events=True) ]] root = sg.Window("PWD Manager 2.1", layout, font=font20, icon=path + "ico.ico") ### FUNCTIONS ### ### CATEGORY: FUNCTION NAME: EVENT KEY ### DB: NEW DB: newdb ### DB: RENAME: rename ### DB: UPLOAD: upload ### KEY: COPY: copy_key ### KEY: SAVE: save_key ### KEY: NEW: change_key ### PWD: ALL: PWDS_ ### PWD: ADD: newpwd ### PWD: SECUREPASS: securepass ### FIRST: TOFIRSTLVL: tofirstlevel ### FIRST: FROMFIRSTLVL: fromfirstlevel ### DICTS: SAVE: savedict ### DICTS: ALL: gui_dicts ### DICTS: NEW: new_dict ### DICTS: IMPORT: import_dict ### NOTES: ADD: newnote ### NOTES: ALL: allnotes while True: events, values = root.read() if events == sg.WIN_CLOSED or events == "exit": root.close() quit(0) ### DB FUNCTIONS ### elif events == "newdb": Big.new_db(sub=False) elif events == "rename": new = values["newname"] + ".aesdb" Big.renamedb(new) root["showdb"].update(Big.name) elif events == "upload": Big.cloudupload() ### KEY FUNCTIONS ### elif events == "copy_key": clipboard(Big.key.decode("utf-8")) elif events == "save_key": # SAVE KEY name = Big.savekey() sg.Popup("Saved To:\n key_" + name, auto_close=True, auto_close_duration=5) elif events == "change_key": Big.new_key(Fernet.generate_key()) Big.encrypt() if fast_load: preferences(save=True) root["showkey"].update(toshow(Big.key.decode("utf-8"), 5)) ### DICTIONARY FUNCTIONS ### elif events == "save_dict": name = "EncryptDict_" + Big.name.strip(".aesdb") + ".dict" file = open(path_dicts + name, "w") file.write(str(Big.dictionary)) file.close() elif events == "gui_dicts": wind_dicts(Big) elif events == "import_dict": window_import = sg.Window( "Import Dictionary", layout=[[ sg.In(), sg.FileBrowse(initial_folder=path_dicts, file_types=("Dict Files", "*.dict")), sg.Button("Ok", key="ok") ]]) events, values = window_import.read() if events == sg.WIN_CLOSED: pass elif events == "ok": if values[0]: imp = eval(open(values[0], "r").read()) Big.Migration(imp) sleep(0.2) root["showdict"].update( toshow(Big.dictionary["A"], 5)) sg.Popup("Success", text_color="green", background_color="black", font=font25, auto_close_duration=1, auto_close=True) window_import.close() elif events == "new_dict": if values["custom"]: wind_custom_dictionary(Big) root["showdict"].update(toshow(Big.dictionary["A"], 5)) elif not values["custom"]: new = new_dictionary(default=True) ch = wind_get_choice("Swap dictionary?", "Yes", "No") if ch: Big.Migration(new) sg.Popup("Success", text_color="green", background_color="black", font=font25, auto_close_duration=4, auto_close=True) root["showdict"].update( toshow(Big.dictionary["A"], 5)) elif not ch: name = wind_get_input( "Name: Leave blank for a gen name", canbeblank=True) if not name: name = "FirstLevel" + ora file = open(path_dicts + name + ".dict", "w") file.write(str(new)) file.close() ### FIRSTLEVEL FUNCTIONS ### elif events == "fromfirstlevel": first = wind_get_input("Firstlevel hash") if not first: pass else: one_shot_copy(Big.fromfirstlevel(first), "Decripted Firstlevel Hash: ") elif events == "tofirstlevel": first = wind_get_input("To Firstlevel: ") if not first: pass else: one_shot_copy(Big.tofirstlevel(first), "Encrypted Firstlevel Hash: ") ### PASSWORDS FUNCTIONS ### elif events == "PWDS_": wind_pwds(Big) elif events == "newpwd": wind_new_pwd(Big) elif events == "securepass": one_shot_copy(secure_pass(randint(10, 14)), "Brand New Password") ### NOTES FUNCTIONS ### elif events == "newnote": wind_new_note(Big) elif events == "notes": wind_notes(Big) ### PREFERENCES ### try: if values["gui"]: if gui: pass else: gui = True preferences(save=True) if values["fast_load"]: if fast_load: pass else: fast_load = True preferences(save=True) if not values["gui"]: gui = False preferences(save=True) root.Close() break if not values["fast_load"]: fast_load = False preferences(save=True) except KeyError: pass ### CLI ### try: print(langs("p", 5) + fg.red + Big.name + fg.norm) print(langs("p", 48)) comando = getinputnoerrors(f"{fg.red}{Big.name}: {fg.norm}") if comando == "add": print(langs("p", 6)) print(langs("p", 21)) user = getinputnoerrors(": ") if user == "gen" or user == "": user = secure_pass(randint(9, 12)) site = getinputnoerrors("URL: ") username = getinputnoerrors("Username: "******"exit": Big.encrypt(True) quit(0) elif comando == "dicts": __dicts__() elif comando == "keys": __keys__() elif comando.__contains__("printall"): Big.printall(comando) elif comando == "__clean_db__": Big.__clean_db__() elif comando.__contains__("print"): key = comando.strip().split(" ")[1] for item in Big.search(key): Big.printpwd(Big.passwords[item]) print("\n") elif comando == "help": for command in langs("c_prompt", 0): print(fg.blue + command[0] + fg.red + " : " + fg.green + command[1] + fg.norm) elif comando == "prefs": preferences(mode="man") elif comando == "upload": Big.cloudupload() elif comando.__contains__("del"): key = comando.split()[1] Big.delete(key=key) elif comando.__contains__("mod"): key = comando.split()[1] res = Big.search(key) new_entry, ind = modpwd_cli(res) Big.modpwd(new_entry, ind) elif comando.__contains__("note"): notes_cli(comando) except ValueError: continue
def charge(self): global fast_load files = [ file for file in os.listdir(path_big_files) if file.endswith(".aesdb") ] try: if not files: self.new_db(sub=True) return if fast_load: try: self.key = fast_load_key self.name = "fastload.aesdb" self.passwords, self.dictionary, self.notes = Big.Deconstruction( (Big.decrypt( open(path_big_files + self.name, "r").read().encode("utf-8")))) self.encrypted = False print(fg.red + "FASTLOADFASTLOADFASTLOAD" + fg.norm) except FileNotFoundError: print(langs("err", 7)) fast_load = False preferences(("f", False)) return except InvalidKey: fast_load = False preferences(("f", False)) return except (InvalidToken, ValueError): fast_load = False preferences(("f", False)) return if not fast_load: if gui: loading_with_gui(Big, files) else: for item in enumerate(files, start=1): print(item[0], item[1]) user = int(getinputnoerrors("Database (1-n|0=new db) : ")) if user == 0: self.new_db(True) else: for file in enumerate(files, start=1): if user == file[0]: self.name = file[1] else: print(langs("err", 3)) return main() self.key = getinputnoerrors("Key: ").encode( "utf-8") self.passwords, self.dictionary, self.notes = Big.Deconstruction( (Big.decrypt( open(path_big_files + self.name, "r").read().encode("utf-8")))) self.encrypted = False print(langs("p", 3)) except FileNotFoundError: print(langs("err", 7)) fast_load = False preferences(("f", False)) return except InvalidKey: print(langs("err", 1)) fast_load = False preferences(("f", False)) return except (InvalidToken, ValueError): print(langs("err", 2)) fast_load = False preferences(("f", False))
def __clean_db__(self): self.passwords = [] print(langs("p", 30)) print(self.encrypt())
def printall(self, comando): def parser_printall(comando): if comando.__contains__("-p"): p = 1 else: p = 0 if comando.__contains__("-d"): d = 1 else: d = 0 if comando.__contains__("-h"): h = 1 else: h = 0 return p, d, h p, d, h = parser_printall(comando) if p == 1: # print all passwords print(fg.green + 'PWDS' + fg.norm) for password in self.passwords: if password: password["plain_pass"] = self.fromfirstlevel( password["firstlevel"]) for item, value in password.items(): row = fg.yellow + item + fg.norm + " : " + fg.red + value + fg.norm if h == 1: # if h parsed then hide the plain_pass if item == "plain_pass": value = "######" row = fg.yellow + item + fg.norm + " : " + fg.red + value + fg.norm print(row) else: print(row) else: print(row) print("\n") else: print(langs("err", 5)) if d == 1: try: # print all dictionary chars and hashes, separated in groups print(fg.green + 'AlphaBeta Dictionary' + fg.norm) row_ups, row_lows, row_digits, row_simbols = "", "", "", "" uppercases_res, lowercases_res, digits_res, simbols_res = [["UPPERCASES",""]], \ [["LOWERCASES",""]], \ [["DIGITS",""]], \ [["NUMBERS",""]] for char, value in self.dictionary.items(): if char in chars_up: uppercases_res.append([char, value]) elif char in chars_down: lowercases_res.append([char, value]) elif char in digits: digits_res.append([char, value]) elif char in simbols: simbols_res.append([char, value]) # Crea liste di caratteri e hash chars = [ uppercases_res, lowercases_res, digits_res, simbols_res ] for l in chars: print(format(l)) print(fg.norm) except AttributeError: print(langs("p", 31)) try: new = new_dictionary(default=True) self.Migration(new) except AttributeError: self.dictionary = new_dictionary(default=True) print(langs("p", 32))