passlocker-tk 1.0.0__tar.gz

passlocker_tk-1.0.0/LICENSE

@@ -0,0 +1,19 @@
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License ("Public License").
+
+You may not use the material for commercial purposes.
+
+You are free to:
+- Share — copy and redistribute the material in any medium or format
+- Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+- Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made.
+- NonCommercial — You may not use the material for commercial purposes.
+- ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
+- No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
+
+For the full license text, see: https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
+
+SPDX-License-Identifier: CC-BY-NC-SA-4.0

passlocker_tk-1.0.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: passlocker-tk
+Version: 1.0.0
+Summary: Password Encryption GUI
+Author-email: Chris Lee <github@chrislee.dhs.org>
+License: CC-BY-NC-SA-4.0
+Project-URL: Homepage, https://github.com/chrislee35/passlocker-tk
+Keywords: encryption,passwords,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: passlocker>=1.0.2
+Requires-Dist: customtkinter>=5.2.2
+Requires-Dist: py-debounce>=0.1.2
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Dynamic: license-file
+
+# Overview
+
+PassLocker-Tk provides a Tkinter interface around using [Passlocker](https://github.com/chrislee35/passlocker), a local-first password management program.
+
+## Screenshot
+
+![Screenshot of Passlocker-Tk](imgs/screenshot-001.png)
+

passlocker_tk-1.0.0/README.md

@@ -0,0 +1,8 @@
+# Overview
+
+PassLocker-Tk provides a Tkinter interface around using [Passlocker](https://github.com/chrislee35/passlocker), a local-first password management program.
+
+## Screenshot
+
+![Screenshot of Passlocker-Tk](imgs/screenshot-001.png)
+

passlocker_tk-1.0.0/passlocker_tk/__init__.py

@@ -0,0 +1,3 @@
+from .gui import PassLockerGui
+
+__all__ = ["PassLockerGui"]

passlocker_tk-1.0.0/passlocker_tk/__main__.py

@@ -0,0 +1,8 @@
+from .gui import PassLockerGui
+
+def main() -> None:
+    app: PassLockerGui = PassLockerGui()
+    app.mainloop()
+
+if __name__ == "__main__":
+    main()

passlocker_tk-1.0.0/passlocker_tk/dialogs/__init__.py

@@ -0,0 +1,16 @@
+from .password_dialog import PasswordDialog
+from .accounts_table import AccountsTable
+from .new_password_account_dialog import NewPasswordAccountDialog
+from .new_otp_account_dialog import NewOTPAccountDialog
+from .new_totp_account_dialog import NewTOTPAccountDialog
+from .about_dialog import AboutDialog
+
+__all__ = [
+    "PasswordDialog",
+    "AccountsTable",
+    "NewPasswordAccountDialog",
+    "NewOTPAccountDialog",
+    "NewTOTPAccountDialog",
+    "AboutDialog",
+    "PasswordDialog",
+]

passlocker_tk-1.0.0/passlocker_tk/dialogs/about_dialog.py

@@ -0,0 +1,88 @@
+import customtkinter as ctk
+import webbrowser
+
+
+class AboutDialog(ctk.CTkToplevel):
+    def __init__(
+        self,
+        parent,
+        *,
+        title,
+        version,
+        author,
+        github_url,
+        description,
+    ):
+        super().__init__(parent)
+
+        self.title("About")
+        self.resizable(False, False)
+
+        # Modal
+        self.transient(parent)
+        self.grab_set()
+
+        self._build_ui(
+            title=title,
+            version=version,
+            author=author,
+            github_url=github_url,
+            description=description,
+        )
+        self._center(parent)
+
+        self.bind("<Escape>", lambda _: self.destroy())
+        self.wait_window()
+
+    # --------------------
+    # UI
+    # --------------------
+    def _build_ui(self, *, title, version, author, github_url, description):
+        frame = ctk.CTkFrame(self)
+        frame.pack(padx=24, pady=24)
+
+        # Title
+        ctk.CTkLabel(frame, text=title, font=ctk.CTkFont(size=20, weight="bold")).pack(
+            anchor="w"
+        )
+
+        # Version / Author
+        ctk.CTkLabel(frame, text=f"Version {version}\n{author}", justify="left").pack(
+            anchor="w", pady=(4, 12)
+        )
+
+        # Description
+        ctk.CTkLabel(frame, text=description, justify="left", wraplength=420).pack(
+            anchor="w", pady=(0, 12)
+        )
+
+        # GitHub link
+        self._link(frame, text="Source code on GitHub", url=github_url).pack(
+            anchor="w", pady=(0, 6)
+        )
+
+        # License link
+        self._link(
+            frame,
+            text="Licensed under CC-BY-NC-SA-4.0",
+            url="https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode",
+        ).pack(anchor="w", pady=(0, 16))
+
+        # Close button
+        ctk.CTkButton(frame, text="Close", width=120, command=self.destroy).pack(
+            anchor="e"
+        )
+
+    # --------------------
+    # Helpers
+    # --------------------
+    def _link(self, parent, *, text, url):
+        lbl = ctk.CTkLabel(parent, text=text, text_color="#4ea1ff", cursor="hand2")
+        lbl.bind("<Button-1>", lambda _: webbrowser.open(url))
+        return lbl
+
+    def _center(self, parent):
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        self.geometry(f"+{x}+{y}")

passlocker_tk-1.0.0/passlocker_tk/dialogs/account_display_dialog.py

@@ -0,0 +1,138 @@
+import customtkinter as ctk
+import tkinter as tk
+from hashlib import sha256
+from secrets import token_bytes
+
+from passlocker.models.account import Account
+
+
+class AccountDisplayDialog(ctk.CTkToplevel):
+    def __init__(self, parent, *, account: Account):
+        super().__init__(parent)
+
+        self.title("Password Record")
+        self.resizable(False, False)
+
+        self.account: Account = account
+
+        self._revealed = False
+        self.iv: bytes = b""
+        self.passhash: str = ""
+
+        # Modal behavior
+        self.transient(parent)
+        self.wait_visibility()
+        self.grab_set()
+
+        self._build_ui()
+        self._center(parent)
+
+        self.bind("<Escape>", lambda _: self.destroy())
+        self.wait_window()
+
+    # --------------------
+    # UI
+    # --------------------
+    def _build_ui(self):
+        container: ctk.CTkFrame = ctk.CTkFrame(self)
+        container.pack(padx=10, pady=10)
+
+        # Account
+        ctk.CTkLabel(container, text="Account").grid(
+            row=0, column=0, sticky="w", padx=5
+        )
+        ctk.CTkLabel(
+            container, text=self.account.account, font=ctk.CTkFont(weight="bold")
+        ).grid(row=0, column=1, sticky="w")
+
+        # Username
+        ctk.CTkLabel(container, text="Username").grid(
+            row=1, column=0, sticky="w", padx=5
+        )
+        ctk.CTkLabel(container, text=self.account.username).grid(
+            row=1, column=1, sticky="w"
+        )
+
+        # Created on
+        ctk.CTkLabel(container, text="Created").grid(
+            row=2, column=0, sticky="w", padx=5
+        )
+        ctk.CTkLabel(container, text=self.account.created_on).grid(
+            row=2, column=1, sticky="w"
+        )
+
+        # Password
+        ctk.CTkLabel(container, text="Password").grid(
+            row=3, column=0, sticky="w", padx=5
+        )
+
+        self.password_var: ctk.StringVar = ctk.StringVar(value="••••••••")
+        self.password_label: ctk.CTkLabel = ctk.CTkLabel(
+            container, textvariable=self.password_var, font=ctk.CTkFont(size=14)
+        )
+        self.password_label.grid(row=3, column=1, sticky="w")
+
+        # Buttons
+        btn_frame: ctk.CTkFrame = ctk.CTkFrame(container, fg_color="transparent")
+        btn_frame.grid(row=4, column=1, sticky="w", pady=(10, 0))
+
+        self.reveal_btn: ctk.CTkButton = ctk.CTkButton(
+            btn_frame, text="Show Password", width=100, command=self.toggle_reveal
+        )
+        self.reveal_btn.grid(row=0, column=0, padx=(0, 10))
+
+        self.copy_btn: ctk.CTkButton = ctk.CTkButton(
+            btn_frame, text="Copy to Clipboard", width=100, command=self.copy_password
+        )
+        self.copy_btn.grid(row=0, column=1)
+
+        container.grid_columnconfigure(1, weight=1)
+
+    # --------------------
+    # Actions
+    # --------------------
+    def toggle_reveal(self):
+        self._revealed = not self._revealed
+
+        if self._revealed:
+            password: bytes = self.account.get_active_password()
+            self.password_var.set(password.decode("utf-8"))
+            self.reveal_btn.configure(text="Hide")
+        else:
+            self.password_var.set("••••••••")
+            self.reveal_btn.configure(text="Reveal")
+
+    def copy_password(self):
+        self.clipboard_clear()
+        password: bytes = self.account.get_active_password()
+        self.iv: bytes = token_bytes(16)
+        self.passhash: str = sha256(self.iv + password).hexdigest()
+        self.clipboard_append(password.decode("utf-8"))
+        self.update()  # ensure clipboard is updated
+        self._schedule_clipboard_clear()
+
+    def _schedule_clipboard_clear(self, delay_ms=15000):
+        self.after(delay_ms, self._clear_clipboard)
+
+    def _clear_clipboard(self):
+        try:
+            checkhash: str = sha256(
+                self.iv + self.clipboard_get().encode("utf-8")
+            ).hexdigest()
+            if checkhash == self.passhash:
+                self.clipboard_clear()
+        except tk.TclError:
+            pass
+
+    # --------------------
+    # Helpers
+    # --------------------
+    def _center(self, parent):
+        self.update_idletasks()
+        x: int = (
+            parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        )
+        y: int = (
+            parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        )
+        self.geometry(f"+{x}+{y}")

passlocker_tk-1.0.0/passlocker_tk/dialogs/accounts_table.py

@@ -0,0 +1,65 @@
+import customtkinter as ctk
+import tkinter as tk
+from tkinter import ttk
+from passlocker.models.account import Account
+from .account_display_dialog import AccountDisplayDialog
+
+
+class AccountsTable(ctk.CTkFrame):
+    def __init__(self, parent: ctk.CTk) -> None:
+        super().__init__(parent)
+
+        columns = ("account", "username", "type")
+
+        self.tree: ttk.Treeview = ttk.Treeview(
+            self, columns=columns, show="headings", height=10
+        )
+
+        # Column definitions
+        self.tree.heading("account", text="Account")
+        self.tree.heading("username", text="Username")
+        self.tree.heading("type", text="Type")
+
+        self.tree.column("account", anchor="w", width=200)
+        self.tree.column("username", anchor="w", width=180)
+        self.tree.column("type", anchor="center", width=80)
+
+        # Scrollbar
+        scrollbar = ttk.Scrollbar(self, orient="vertical", command=self.tree.yview)
+        self.tree.configure(yscrollcommand=scrollbar.set)
+
+        # Layout
+        self.tree.grid(row=0, column=0, sticky="nsew")
+        scrollbar.grid(row=0, column=1, sticky="ns")
+
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=1)
+
+        self.tree.bind("<Double-1>", self.on_open_account)
+        self._accounts_by_id: dict[int, Account] = {}
+
+    # --------------------
+    # Public API
+    # --------------------
+    def populate(self, accounts: list[Account]) -> None:
+        """
+        accounts: iterable of objects or dicts
+        expected fields: account, username, type
+        """
+        self.tree.delete(*self.tree.get_children())
+
+        for acc in accounts:
+            self.tree.insert(
+                "", "end", iid=id(acc), values=(acc.account, acc.username, acc.type)
+            )
+        self._accounts_by_id: dict[int, Account] = {id(acc): acc for acc in accounts}
+
+    def on_open_account(self, event: tk.Event) -> None:
+        selected = self.tree.selection()
+        if not selected:
+            return
+        item_id = int(selected[0])
+        account = self._accounts_by_id.get(item_id)
+        if account is None:
+            return
+        _ = AccountDisplayDialog(self, account=account)

passlocker_tk-1.0.0/passlocker_tk/dialogs/generate_password_dialog.py

@@ -0,0 +1,209 @@
+import customtkinter as ctk
+from tkinter import ttk
+import secrets
+
+
+class GeneratePasswordDialog(ctk.CTkToplevel):
+    def __init__(self, parent) -> None:
+        super().__init__(parent)
+
+        self.title("Generate Password")
+        self.resizable(False, False)
+
+        self.result: str | None = None
+
+        # Modal behavior
+        self.transient(parent)
+        self.wait_visibility()
+        self.grab_set()
+
+        self._build_ui()
+        self._center(parent)
+
+        self.bind("<Escape>", lambda _: self._cancel())
+
+        self.wait_window()
+
+    # --------------------
+    # UI
+    # --------------------
+    def _build_ui(self) -> None:
+        root = ctk.CTkFrame(self)
+        root.pack(padx=20, pady=20)
+
+        # ---- Controls ----
+        controls = ctk.CTkFrame(root)
+        controls.pack(fill="x")
+
+        # Algorithm selector
+        ctk.CTkLabel(controls, text="Algorithm").grid(row=0, column=0, sticky="w")
+
+        self.algorithm_var = ctk.StringVar(value="random")
+        self.algorithm_menu = ctk.CTkOptionMenu(
+            controls,
+            variable=self.algorithm_var,
+            values=["random", "memorable", "numeric"],
+            width=140,
+        )
+        self.algorithm_menu.grid(row=0, column=1, padx=(10, 20))
+
+        # Length selector
+        ctk.CTkLabel(controls, text="Length").grid(row=0, column=2, sticky="w")
+
+        self.length_var = ctk.IntVar(value=16)
+        self.length_slider = ctk.CTkSlider(
+            controls, from_=8, to=64, number_of_steps=56, command=self._on_length_change
+        )
+        self.length_slider.set(16)
+        self.length_slider.grid(row=0, column=3, padx=(10, 10))
+
+        self.length_label = ctk.CTkLabel(controls, text="16", width=32, anchor="e")
+        self.length_label.grid(row=0, column=4)
+
+        controls.grid_columnconfigure(3, weight=1)
+
+        # Generate button
+        self.generate_btn = ctk.CTkButton(root, text="Generate", command=self._generate)
+        self.generate_btn.pack(pady=(10, 10))
+
+        # ---- Table ----
+        table_frame = ctk.CTkFrame(root)
+        table_frame.pack()
+
+        self.tree = ttk.Treeview(
+            table_frame, columns=("password",), show="headings", height=10
+        )
+        self.tree.heading("password", text="Generated Password")
+        self.tree.column("password", anchor="w", width=320)
+
+        scrollbar = ttk.Scrollbar(
+            table_frame, orient="vertical", command=self.tree.yview
+        )
+        self.tree.configure(yscrollcommand=scrollbar.set)
+
+        self.tree.grid(row=0, column=0, sticky="nsew")
+        scrollbar.grid(row=0, column=1, sticky="ns")
+
+        table_frame.grid_rowconfigure(0, weight=1)
+        table_frame.grid_columnconfigure(0, weight=1)
+
+        # Double-click selection
+        self.tree.bind("<Double-1>", self._on_select)
+
+    # --------------------
+    # Actions
+    # --------------------
+    def _on_length_change(self, value):
+        self.length_label.configure(text=str(int(value)))
+
+    def _generate(self):
+        algorithm = self.algorithm_var.get()
+        length = self.length_var.get()
+
+        passwords = self.generate_passwords(algorithm, length, count=10)
+        self.tree.delete(*self.tree.get_children())
+
+        for pw in passwords:
+            self.tree.insert("", "end", values=(pw,))
+
+    def _on_select(self, event):
+        selection = self.tree.selection()
+        if not selection:
+            return
+
+        self.result = self.tree.item(selection[0], "values")[0]
+        self.destroy()
+
+    def _cancel(self):
+        self.result = None
+        self.destroy()
+
+    # --------------------
+    # Helpers
+    # --------------------
+    def _center(self, parent):
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        self.geometry(f"+{x}+{y}")
+
+    def generate_passwords(
+        self, algorithm: str, length: int, count: int = 10
+    ) -> list[str]:
+        if algorithm == "memorable":
+            return [self.generate_memorable(length) for _ in range(count)]
+        elif algorithm == "random":
+            return [self.generate_random(length) for _ in range(count)]
+        elif algorithm == "numeric":
+            return [self.generate_numbers(length) for _ in range(count)]
+        else:
+            raise Exception(f"Unknown generation algorithm: {algorithm}")
+
+    def generate_memorable(self, length: int) -> str:
+        if length <= 8:
+            maxnum = 100
+            special = 0
+        elif length <= 16:
+            maxnum = 1000
+            special = 1
+        elif length <= 24:
+            maxnum = 10000
+            special = 2
+        else:
+            maxnum = 100000
+            special = 3
+
+        random_int: int = secrets.randbelow(maxnum)
+        random_special: str = "".join(
+            secrets.choice(
+                [
+                    "!",
+                    "@",
+                    "#",
+                    "$",
+                    "%",
+                    "^",
+                    "&",
+                    "*",
+                    "(",
+                    ")",
+                    "-",
+                    "_",
+                    "+",
+                    "=",
+                    "{",
+                    "}",
+                    "[",
+                    "]",
+                    ":",
+                    ";",
+                    "<",
+                    ">",
+                    ".",
+                    ",",
+                    "?",
+                    "/",
+                    "~",
+                    "`",
+                ]
+            )
+            for i in range(special)
+        )
+
+        secret_sauce = f"{random_int}{random_special}"
+        password: str = ""
+
+        with open("/usr/share/dict/words") as f:
+            words: list[str] = [word.strip() for word in f]
+            genlen: int = 0
+            while genlen != length:
+                password = secret_sauce.join(secrets.choice(words) for _ in range(2))
+                genlen = len(password)
+
+        return password
+
+    def generate_random(self, length: int) -> str:
+        return secrets.token_urlsafe(32)[0:length]
+
+    def generate_numbers(self, length: int) -> str:
+        return "".join([str(secrets.choice(range(10))) for i in range(length)])

passlocker_tk-1.0.0/passlocker_tk/dialogs/new_otp_account_dialog.py

@@ -0,0 +1,94 @@
+import customtkinter as ctk
+
+
+class NewOTPAccountDialog(ctk.CTkToplevel):
+    def __init__(self, parent):
+        super().__init__(parent)
+
+        self.title("New Account")
+        self.resizable(False, False)
+
+        self.result = None
+
+        # Modal behavior
+        self.transient(parent)
+        self.grab_set()
+
+        self._build_ui()
+        self._center(parent)
+
+        self.bind("<Escape>", lambda _: self._cancel())
+        self.bind("<Return>", lambda _: self._ok())
+
+        self.wait_window()
+
+    # --------------------
+    # UI
+    # --------------------
+    def _build_ui(self):
+        frame = ctk.CTkFrame(self)
+        frame.pack(padx=20, pady=20)
+
+        # Variables
+        self.account_var = ctk.StringVar()
+        self.username_var = ctk.StringVar()
+
+        # Account name
+        ctk.CTkLabel(frame, text="Account").grid(row=0, column=0, sticky="w")
+        self.account_entry = ctk.CTkEntry(
+            frame, textvariable=self.account_var, width=260
+        )
+        self.account_entry.grid(row=0, column=1, pady=5)
+        self.account_entry.focus()
+
+        # Username
+        ctk.CTkLabel(frame, text="Username").grid(row=1, column=0, sticky="w")
+        ctk.CTkEntry(frame, textvariable=self.username_var, width=260).grid(
+            row=1, column=1, pady=5
+        )
+
+        # Password
+        ctk.CTkLabel(frame, text="Passwords").grid(row=2, column=0, sticky="w")
+        self.password_entry = ctk.CTkTextbox(frame, width=260, height=112)
+        self.password_entry.grid(row=2, column=1, pady=5)
+
+        # Buttons
+        btn_frame = ctk.CTkFrame(frame, fg_color="transparent")
+        btn_frame.grid(row=3, column=1, pady=(15, 0), sticky="e")
+
+        ctk.CTkButton(btn_frame, text="Cancel", width=100, command=self._cancel).grid(
+            row=0, column=0, padx=(0, 10)
+        )
+
+        self.ok_btn = ctk.CTkButton(btn_frame, text="OK", width=100, command=self._ok)
+        self.ok_btn.grid(row=0, column=1)
+
+        frame.grid_columnconfigure(1, weight=1)
+
+    def _ok(self):
+        account = self.account_var.get().strip()
+        username = self.username_var.get().strip()
+        password = self.password_entry.get("0.0", ctk.END)
+
+        if not account or not password:
+            return  # minimal validation; extend as needed
+
+        self.result = {
+            "account": account,
+            "username": username,
+            "password": password,
+        }
+        self.destroy()
+
+    def _cancel(self):
+        self.result = None
+        self.destroy()
+
+    # --------------------
+    # Helpers
+    # --------------------
+    def _center(self, parent):
+        self.update_idletasks()
+        x = parent.winfo_x() + (parent.winfo_width() // 2) - (self.winfo_width() // 2)
+        y = parent.winfo_y() + (parent.winfo_height() // 2) - (self.winfo_height() // 2)
+        self.geometry(f"+{x}+{y}")