rclone_decrypt 0.1.2__tar.gz

rclone_decrypt-0.1.2/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Mitchell Thompkins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rclone_decrypt-0.1.2/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: rclone_decrypt
+Version: 0.1.2
+Summary: Wrapper around rclone to decrypt files encrypted with rclone
+Home-page: https://github.com/MitchellThompkins/rclone-decrypt
+License: MIT
+Author: Mitchell Thompkins
+Author-email: mitchell.thompkins@gmail.com
+Requires-Python: >=3.8.1
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: click (>=8.1.3,<9.0.0)
+Requires-Dist: python-rclone (>=0.0.2,<0.0.3)
+Requires-Dist: python-statemachine (>=2.0.0,<3.0.0)
+Requires-Dist: tkinterdnd2 (>=0.3.0,<0.4.0)
+Project-URL: Repository, https://github.com/MitchellThompkins/rclone-decrypt
+Description-Content-Type: text/markdown
+
+# rclone-decrypt
+## Status
+![test](https://github.com/mitchellthompkins/rclone-decrypt/actions/workflows/test.yml/badge.svg)
+![build](https://github.com/mitchellthompkins/rclone-decrypt/actions/workflows/build_app.yml/badge.svg)
+
+## Description
+`rclone-decrypt` is a utility which will decrypt files that were encrypted with
+[rclone](https://rclone.org/). The anticipated use-case is that a user has
+independently downloaded an **encrypted** file or directory directly from a
+remote cloud storage (Backblaze B2/Amazon Drive/Dropbox/etc...) and now wants to
+decrypt it.
+
+Given an rclone.conf file, this tool is simply a wrapper around `rclone` which
+sets up a "local remote" to host the downloaded encrypted files and then calls
+`rclone copy` in order to decrypt the files into a desired output folder.
+
+Ostensibly I did this because my family backs-up our local NAS to a remote host
+but the rest of my family prefers to download files one-off from the cloud host
+and are not comfortable using the rclone CLI. This offers a CLI in addition to
+an easy-to-use GUI to make life simple.
+
+### Notes
+* **Use at your own risk! Be sure you have copies of anything you're trying to
+decrypt, just in case something goes wrong!**
+* When decrypting files with encrypted filenames or folder names, the directory
+  or filename must _only_ consist of the encrypted version. For example, if an
+  encrypted file was downloaded as `path_to_encypted_file_4567asd8fasdf67asdf`
+  where `4567asd8fasdf67asdf` is the encrypted part, the filename must be
+  renamed to exclude the `path_to_encypted_file_` portion. Otherwise rclone will
+  complain about invalid encryption names.
+* Windows is _not_ currently supported, although it probably would not take very
+  much work to get it there. I do not have ready access to a windows environment
+  on which to test.
+* I'd love to make the GUI look more modern, but most solutions involve a style
+  which seems incompatible with
+  [tkinterdnd2](https://github.com/Eliav2/tkinterdnd2) which provides the drag
+  and drop feature.
+
+## Installation
+```
+pip3 install rclone-decrypt
+```
+
+## Requirements
+### General
+* `rclone` must be installed and in `$PATH`
+
+### Python environment
+* `Python >= 3.7 <3.12`
+* `Python-tk` must be installed if using the GUI
+
+### Executable
+**UNDER DEVELOPMENT** An OSX `.app` is generated but is currently untested.
+
+## Usage
+### CLI usage
+```
+> rclone-decrypt --config /path/to/rclone.conf --files /path/to/file/or/dir/
+```
+
+Example usages:
+```
+> rclone-decrypt --config rclone.conf --files /home/my_encrypted_dir
+> rclone-decrypt --config rclone.conf --files /0f12hh28evsof1kgflv67ldcn/9g6h49o4ht35u7o5e4iv5a1h28
+> rclone-decrypt --config rclone.conf --files /home/my_encrypted_file.bin
+```
+### GUI usage
+If the python package is installed directly then the GUI can be invoked from the
+command line, as shown below. Otherwise the packaged binary can be downloaded
+and executed directly.
+* Files can be dropped directly into the big white box.
+* As files are dropped, if no output directory has been provided though the file
+  dialog, an output directory called 'out' will be created at the same directory
+  level as the last dropped file to be decrypted.
+* A default location for `rclone.conf` is provided, others can be browsed for.
+```
+rclone-decrypt --gui
+```
+
+![rclone_example](docs/imgs/rclone_gui.png)
+
+## Development
+```
+source .venv/bin/activate
+poetry install
+poetry run pytest
+poetry run flake8
+deactivate
+```
+

rclone_decrypt-0.1.2/README.md

@@ -0,0 +1,89 @@
+# rclone-decrypt
+## Status
+![test](https://github.com/mitchellthompkins/rclone-decrypt/actions/workflows/test.yml/badge.svg)
+![build](https://github.com/mitchellthompkins/rclone-decrypt/actions/workflows/build_app.yml/badge.svg)
+
+## Description
+`rclone-decrypt` is a utility which will decrypt files that were encrypted with
+[rclone](https://rclone.org/). The anticipated use-case is that a user has
+independently downloaded an **encrypted** file or directory directly from a
+remote cloud storage (Backblaze B2/Amazon Drive/Dropbox/etc...) and now wants to
+decrypt it.
+
+Given an rclone.conf file, this tool is simply a wrapper around `rclone` which
+sets up a "local remote" to host the downloaded encrypted files and then calls
+`rclone copy` in order to decrypt the files into a desired output folder.
+
+Ostensibly I did this because my family backs-up our local NAS to a remote host
+but the rest of my family prefers to download files one-off from the cloud host
+and are not comfortable using the rclone CLI. This offers a CLI in addition to
+an easy-to-use GUI to make life simple.
+
+### Notes
+* **Use at your own risk! Be sure you have copies of anything you're trying to
+decrypt, just in case something goes wrong!**
+* When decrypting files with encrypted filenames or folder names, the directory
+  or filename must _only_ consist of the encrypted version. For example, if an
+  encrypted file was downloaded as `path_to_encypted_file_4567asd8fasdf67asdf`
+  where `4567asd8fasdf67asdf` is the encrypted part, the filename must be
+  renamed to exclude the `path_to_encypted_file_` portion. Otherwise rclone will
+  complain about invalid encryption names.
+* Windows is _not_ currently supported, although it probably would not take very
+  much work to get it there. I do not have ready access to a windows environment
+  on which to test.
+* I'd love to make the GUI look more modern, but most solutions involve a style
+  which seems incompatible with
+  [tkinterdnd2](https://github.com/Eliav2/tkinterdnd2) which provides the drag
+  and drop feature.
+
+## Installation
+```
+pip3 install rclone-decrypt
+```
+
+## Requirements
+### General
+* `rclone` must be installed and in `$PATH`
+
+### Python environment
+* `Python >= 3.7 <3.12`
+* `Python-tk` must be installed if using the GUI
+
+### Executable
+**UNDER DEVELOPMENT** An OSX `.app` is generated but is currently untested.
+
+## Usage
+### CLI usage
+```
+> rclone-decrypt --config /path/to/rclone.conf --files /path/to/file/or/dir/
+```
+
+Example usages:
+```
+> rclone-decrypt --config rclone.conf --files /home/my_encrypted_dir
+> rclone-decrypt --config rclone.conf --files /0f12hh28evsof1kgflv67ldcn/9g6h49o4ht35u7o5e4iv5a1h28
+> rclone-decrypt --config rclone.conf --files /home/my_encrypted_file.bin
+```
+### GUI usage
+If the python package is installed directly then the GUI can be invoked from the
+command line, as shown below. Otherwise the packaged binary can be downloaded
+and executed directly.
+* Files can be dropped directly into the big white box.
+* As files are dropped, if no output directory has been provided though the file
+  dialog, an output directory called 'out' will be created at the same directory
+  level as the last dropped file to be decrypted.
+* A default location for `rclone.conf` is provided, others can be browsed for.
+```
+rclone-decrypt --gui
+```
+
+![rclone_example](docs/imgs/rclone_gui.png)
+
+## Development
+```
+source .venv/bin/activate
+poetry install
+poetry run pytest
+poetry run flake8
+deactivate
+```

rclone_decrypt-0.1.2/pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "rclone_decrypt"
+version = "0.1.2"
+description = "Wrapper around rclone to decrypt files encrypted with rclone"
+authors = ["Mitchell Thompkins <mitchell.thompkins@gmail.com>"]
+license = "MIT"
+
+repository = "https://github.com/MitchellThompkins/rclone-decrypt"
+
+# README file(s) are used as the package description
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = ">=3.8.1"
+click = "^8.1.3"
+python-rclone = "^0.0.2"
+python-statemachine = "^2.0.0"
+tkinterdnd2 = "^0.3.0"
+
+[tool.poetry.dev-dependencies]
+pytest = "^5.2"
+flake8 = "^6.0.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+rclone-decrypt = "rclone_decrypt.cli:cli"

rclone_decrypt-0.1.2/src/rclone_decrypt/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

rclone_decrypt-0.1.2/src/rclone_decrypt/cli.py

@@ -0,0 +1,49 @@
+import click
+import rclone_decrypt.decrypt as decrypt
+import rclone_decrypt.gui as GUI
+
+
+@click.command()
+@click.option(
+    "--config",
+    help=f"config file. default config file is:\
+        {decrypt.default_rclone_conf_dir}",
+    default=decrypt.default_rclone_conf_dir,
+    required=True,
+)
+@click.option(
+    "--files",
+    help="dir or file to decrypt",
+    default=None)
+@click.option(
+    "--output_dir",
+    help=f"output dir in which to put files. default folder is:\
+            {decrypt.default_output_dir}",
+    default=decrypt.default_output_dir,
+)
+@click.option(
+    "--gui",
+    help="start the GUI",
+    is_flag=True,
+    default=False)
+@click.option(
+    "--gui_debug",
+    help="print debug messages",
+    is_flag=True,
+    default=False)
+def cli(config, files, output_dir, gui, gui_debug):
+    if gui is True:
+        GUI.start_gui(gui_debug)
+    else:
+        try:
+            if files is None:
+                raise ValueError("files cannot be None")
+            else:
+                decrypt.decrypt(files, config, output_dir)
+
+        except ValueError as err:
+            decrypt.print_error(err)
+
+
+if __name__ == "__main__":
+    cli()

rclone_decrypt-0.1.2/src/rclone_decrypt/decrypt.py

@@ -0,0 +1,223 @@
+import os
+import rclone
+import re
+import tempfile
+
+from statemachine import StateMachine, State
+
+default_output_dir = "out"
+
+# TODO(mitchellthompkins): This won't work on windows, check the rclone
+# documentation for the windows default location
+default_rclone_conf_dir = os.path.join(
+    os.environ["HOME"], ".config", "rclone", "rclone.conf"
+)
+
+
+class ConfigFileError(Exception):
+    def __init__(self, *args, **kwargs):
+        default_message = """There is a problem with the rclone
+        configuration file"""
+
+        if not args:
+            args = (default_message,)
+
+        # Call super constructor
+        super().__init__(*args, **kwargs)
+
+
+def print_error(msg: str) -> None:
+    """
+    Print generic error.
+    """
+    print(f"ERROR: {msg}")
+
+
+class ConfigWriterControl(StateMachine):
+    searching_for_start = State(initial=True)
+    type_check = State()
+    writing = State()
+    completed = State(final=True)
+
+    search = searching_for_start.to(searching_for_start)
+    validate = searching_for_start.to(type_check)
+    is_valid = type_check.to(writing)
+    is_invalid = type_check.to(searching_for_start)
+    write = type_check.to(writing) | writing.to(writing)
+    write_complete = writing.to(searching_for_start)
+    complete = searching_for_start.to(completed) | writing.to(completed)
+
+    def __init__(self, cfg_file: str) -> None:
+        self.cfg_file = cfg_file
+        self.cached_entry_start = None
+
+        super(ConfigWriterControl, self).__init__()
+
+    def before_validate(self, line: str) -> None:
+        self.cached_entry_start = line
+
+    def before_write(self, line: str) -> None:
+        self.cfg_file.write(line)
+
+    def before_is_valid(self, line: str) -> None:
+        self.cfg_file.write(self.cached_entry_start)
+        self.cfg_file.write(line)
+
+
+def get_rclone_instance(config: str, files: str,
+                        remote_folder_name: str) -> rclone.RClone:
+    """
+    Opens a config file and strips out all of the non-crypt type entries,
+    modifies the remote to be local directory.
+
+    Returns an rclone instance.
+    """
+    rclone_instance = None
+
+    try:
+        with open(config, "r") as f:
+            config_file = f.readlines()
+
+            with tempfile.NamedTemporaryFile(mode="wt", delete=True)\
+                    as tmp_config_file:
+
+                with open(tmp_config_file.name, "w") as config:
+                    config_state = ConfigWriterControl(config)
+
+                    for line in config_file:
+                        if config_state.current_state.id ==\
+                                "searching_for_start":
+                            start_of_entry = re.search("\\[.*?\\]", line)
+
+                            if start_of_entry is not None:
+                                config_state.validate(line)
+                            else:
+                                config_state.search()
+
+                        elif config_state.current_state.id == "type_check":
+                            entry_type = re.search(
+                                    "type\\s*=\\s*([\\S\\s]+)", line)
+                            if entry_type is not None:
+                                entry_type = entry_type.group(1).strip()
+                                if entry_type == "crypt":
+                                    config_state.is_valid(
+                                            f"type = {entry_type}\n")
+                                else:
+                                    config_state.is_invalid()
+
+                        elif config_state.current_state.id == "writing":
+                            remote = re.search(
+                                    "remote\\s*=\\s*([\\S\\s]+)", line)
+                            if remote is not None:
+                                config_state.write(
+                                    f"remote =\
+                                        {remote_folder_name}/\n"
+                                )
+
+                            elif line == "\n":
+                                config_state.write(line)
+                                config_state.write_complete()
+
+                            else:
+                                config_state.write(line)
+
+                    config_state.complete()
+
+                # Open the modified temporary file and create our instance
+                with open(tmp_config_file.name, "r") as t:
+                    o = t.read()
+                    rclone_instance = rclone.with_config(o)
+
+        # I think that given a file, any file, rclone.with_config() will always
+        # return _something_ as it doesn't validate the config file
+        if rclone_instance is None:
+            raise ConfigFileError("The rclone instance was not created.")
+
+    except FileNotFoundError as err:
+        print_error(err)
+
+    return rclone_instance
+
+
+def rclone_copy(rclone_instance: rclone.RClone, output_dir: str) -> None:
+    """
+    Calls the rclone copy function via a shell instance and places the
+    decrypted files into the output_dir
+    """
+    # convert list of remotes in str format into a list
+    remotes = rclone_instance.listremotes()["out"].decode().splitlines()
+
+    for r in remotes:
+        rclone_instance.copy(f"{r}", f"{output_dir}")
+        # TODO(@mitchellthompkins): rclone.copy still returns 0 for an
+        # unsuccessful decryption. As long as the call itself doesn't fail, it
+        # will return 0.  Need to come up with someway to detect success
+        # if success['code'] == 0:
+        #    break
+
+
+def decrypt(
+    files: str,
+    config: str = default_rclone_conf_dir,
+    output_dir: str = default_output_dir
+        ) -> None:
+    """
+    Sets up the files or directories to be decrypted by moving them to the
+    correct relative path. The appropriate temporary config file is generated
+    and the appropriate rclone_copy function is then called to perform the
+    decryption.
+
+    Explicitly, this creates a temporary directory at the same root as where
+    this is called from, moves the files (or file) to be decrypted to that
+    directory, modifies a temporary config file in order to point rclone to a
+    folder in _this_ directory, calls `rclone --config config file copy
+    remote:local_tmp_dir out` and then moves the files back to their original
+    location.
+    """
+    try:
+        with tempfile.TemporaryDirectory(dir=os.getcwd()) as temp_dir_name:
+            rclone_instance = get_rclone_instance(config, files, temp_dir_name)
+
+            if rclone_instance is None:
+                raise ConfigFileError("rclone_instance cannot be None")
+
+            if output_dir is default_output_dir:
+                # If no output_dir is provided, put the de-crypted file into a
+                # folder called 'out' that lives at the same base dir as that
+                # of the input file
+                base_file_dir = os.path.basename(
+                        os.path.dirname(files))
+
+                file_input_dir = os.path.dirname(
+                        os.path.abspath(base_file_dir))
+
+                output_dir = os.path.join(file_input_dir, output_dir)
+
+            # if the output folder doesn't exist, make it
+            if not os.path.isdir(output_dir):
+                os.mkdir(output_dir)
+
+            # When folder names are encrypted, I don't think that the config
+            # file can look wherever it wants in a sub directory, so the folder
+            # we're looking for must live in the same root directory as where
+            # rclone is called from
+            actual_path = os.path.abspath(files)
+            dir_or_file_name = os.path.basename(actual_path)
+            temp_file_path = os.path.join(temp_dir_name, dir_or_file_name)
+
+            # Move the folder
+            os.rename(actual_path, temp_file_path)
+
+            try:
+                # Do the copy, we wrap this in a try in case the user
+                # interrupts the process, otherwise the file won't be
+                # moved back
+                rclone_copy(rclone_instance, output_dir)
+            except KeyboardInterrupt:
+                print("\n\tterminated rclone copy!")
+
+            # Move it back
+            os.rename(temp_file_path, actual_path)
+
+    except ConfigFileError as err:
+        print_error(err)

rclone_decrypt-0.1.2/src/rclone_decrypt/gui.py

@@ -0,0 +1,163 @@
+import logging
+import os
+import tkinter
+import tkinter.filedialog
+import rclone_decrypt.decrypt as decrypt
+
+from tkinterdnd2 import DND_FILES, TkinterDnD
+
+
+class DecryptWindow:
+    def __init__(self, title: str, geometry: str, debug: bool):
+        self.title = title
+        self.geometry = geometry
+        self.window = TkinterDnD.Tk()
+        self.selected_entry = None
+        self.defined_output_dir = False
+
+        self.debug = debug
+        self.files = []
+        self.config_file = decrypt.default_rclone_conf_dir
+        self.output_dir = decrypt.default_output_dir
+
+        self.browse_config_button = tkinter.Button(
+            self.window, text="Browse", command=self.get_config
+        )
+
+        self.browse_output_button = tkinter.Button(
+            self.window, text="Browse", command=self.get_output
+        )
+
+        self.remove_button = tkinter.Button(
+            self.window, text="Remove Selected", command=self.remove_entry
+        )
+
+        self.decrypt_button = tkinter.Button(
+            self.window, text="Decrypt", command=self.decrypt
+        )
+
+        self.lb = tkinter.Listbox(self.window, width=66, height=10)
+
+        self.config_label = tkinter.Label(
+                self.window, text="Select a config file:")
+
+        self.output_label = tkinter.Label(
+            self.window, text="Select an output directory:"
+        )
+
+        self.instruction_label = tkinter.Label(
+            self.window,
+            text="\nDrag files and folders to decrypt into the box below:"
+        )
+
+        self.config_entry = tkinter.Text(self.window, height=1, width=70)
+        self.config_entry.insert(tkinter.END, self.config_file)
+        self.config_entry.config(state=tkinter.DISABLED)
+
+        self.output_entry = tkinter.Text(self.window, height=1, width=70)
+        self.output_entry.insert(tkinter.END, self.output_dir)
+        self.output_entry.config(state=tkinter.DISABLED)
+
+    def decrypt(self):
+        for f in self.files:
+            # Files with spaces get {} prepended and appended
+            f = f.strip("{}")
+            decrypt.decrypt(f, self.config_file, self.output_dir)
+
+    def select(self, evt):
+        if len(self.files) != 0:
+            self.selected_entry = self.lb.get(self.lb.curselection())
+
+    def get_config(self):
+        file = tkinter.filedialog.askopenfile(
+            mode="r", filetypes=[("rclone config", "*.conf")]
+        )
+        if file:
+            self.config_file = os.path.abspath(file.name)
+
+            self.config_entry.config(state=tkinter.NORMAL)
+            self.config_entry.delete("1.0", tkinter.END)
+            self.config_entry.insert(tkinter.END, self.config_file)
+            self.config_entry.config(state=tkinter.DISABLED)
+
+    def get_output(self):
+        dir = tkinter.filedialog.askdirectory()
+        if dir:
+            self.output_dir = os.path.abspath(dir)
+            self.defined_output_dir = True
+
+            self.output_entry.config(state=tkinter.NORMAL)
+            self.output_entry.delete("1.0", tkinter.END)
+            self.output_entry.insert(tkinter.END, self.output_dir)
+            self.output_entry.config(state=tkinter.DISABLED)
+
+    def add_to_list(self, path):
+        if path not in self.files:
+            self.files.append(path)
+            self.lb.insert(tkinter.END, path)
+        else:
+            if self.debug:
+                logging.warning(f"{path} already in list.")
+
+        if self.defined_output_dir is False:
+            self.output_dir = decrypt.default_output_dir
+
+            dirname = os.path.dirname(path.strip("{}"))
+            self.output_dir = os.path.join(dirname, self.output_dir)
+
+            self.output_entry.config(state=tkinter.NORMAL)
+            self.output_entry.delete("1.0", tkinter.END)
+            self.output_entry.insert(tkinter.END, self.output_dir)
+            self.output_entry.config(state=tkinter.DISABLED)
+
+    def remove_entry(self):
+        if self.selected_entry is not None:
+            self.files.remove(self.selected_entry)
+
+            entry = self.lb.get(0, tkinter.END).index(self.selected_entry)
+            self.lb.delete(entry)
+            self.selected_entry = None
+
+    def render(self):
+        self.window.title(self.title)
+        self.window.geometry(self.geometry)
+
+        self.lb.drop_target_register(DND_FILES)
+        self.lb.dnd_bind("<<Drop>>", lambda e: self.add_to_list(e.data))
+        self.lb.bind("<<ListboxSelect>>", self.select)
+
+        # row0
+        self.config_label.grid(sticky="E", row=0, column=0, pady=2)
+        self.config_entry.grid(row=0, column=1, pady=2)
+        self.browse_config_button.grid(
+                sticky="W", row=0, column=2, padx=10, pady=2)
+
+        # row1
+        self.output_label.grid(sticky="E", row=1, column=0, pady=2)
+        self.output_entry.grid(row=1, column=1, pady=2)
+        self.browse_output_button.grid(
+                sticky="W", row=1, column=2, padx=10, pady=2)
+
+        # row2
+        self.instruction_label.grid(row=2, column=1, padx=10, pady=2)
+
+        # row3
+        self.lb.grid(row=3, column=1, padx=2, pady=2)
+        self.remove_button.grid(sticky="W", row=3, column=2, padx=10, pady=20)
+
+        # row4
+        self.decrypt_button.grid(row=4, column=1, pady=20)
+
+        self.window.mainloop()
+
+
+def start_gui(debug: bool = False):
+    title = "rclone-decrypt"
+    geometry = "1770x600+100+200"
+
+    w = DecryptWindow(title, geometry, debug)
+    w.render()
+
+
+if __name__ == "__main__":
+    start_gui()