Updated documentation for release v1.1.1

Former-commit-id: defed7054804d7bf36e93c302282039d335d6561 [formerly 558512ba52]
Former-commit-id: f6cf7d3e5633652439a46c51f9d5cfad007f2236

.SRCINFO

@@ -1,15 +0,0 @@
-pkgbase = rpass
-	pkgdesc = An rsync-based password manager and alternative to GNU pass
-	pkgver = 2021.09.07.pr3.1
-	pkgrel = 1
-	arch = x86_64
-	arch = aarch64
-	license = GPL3
-	depends = python
-	depends = gnupg
-	depends = openssh
-	depends = rsync
-	source = https://cloud.watergateserver.xyz/api/public/dl/6b0Wqz-J
-	sha512sums = f59cd1cd3c981b9424fba85bfd5e7b33e26a482d48b9b47a77be6f8e7cecbf078ec956a46b37db488d5173cd0a439f572ff06fc7d35cc3e9b0a7666e49cadeee
-
-pkgname = rpass

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,72 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "main" ]
+  schedule:
+    - cron: '34 22 * * 5'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'python' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+        
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

PKGBUILD

@@ -1,21 +0,0 @@
-# Maintainer: Randall Winkhart (Cuan) <idgr at tutanota dot com>
-
-pkgname=rpass
-pkgver=2021.09.07.pr3.1
-pkgrel=1
-pkgdesc="An rsync-based password manager and alternative to GNU pass"
-arch=('x86_64' 'aarch64')
-license=('GPL3')
-depends=( python gnupg openssh rsync )
-
-source=('https://cloud.watergateserver.xyz/api/public/dl/6b0Wqz-J')
-sha512sums=('f59cd1cd3c981b9424fba85bfd5e7b33e26a482d48b9b47a77be6f8e7cecbf078ec956a46b37db488d5173cd0a439f572ff06fc7d35cc3e9b0a7666e49cadeee')
-
-package() {
-
-    mv 6b0Wqz-J rpass-2021.09.07.pr3.1.tar.xz
-	tar xf rpass-2021.09.07.pr3.1.tar.xz -C "${pkgdir}"
-	chown -R "$USER" ${pkgdir}/var/lib/rpass
-
-}
-

README.md

@@ -1,14 +1,100 @@
-# rpass
-A password manager with rsync integration - alternative to GNU pass
+![sshyp](https://github.com/rwinkhart/sshyp-labs/blob/main/extra/artwork/sshyp-banner.png)
+
+[![CodeQL](https://github.com/rwinkhart/sshyp/actions/workflows/codeql-analysis.yml/badge.svg?branch=main)](https://github.com/rwinkhart/sshyp/actions/workflows/codeql-analysis.yml)
+
+sshyp is a very simple self-hosted, synchronized password manager for UNIX(-like) systems (currently Haiku/FreeBSD/Linux).
+
+sshyp is compatible with entries created by pass/password-store, as its original goal was to be like pass/password-store, but far more user-friendly to synchronize with a self-hosted server.
+
+sshyp is (as of writing) the only password-store compatible CLI password manager available for Haiku.
+
+sshyp makes use of a custom sftp wrapper, called sshync (ssh+sync), to reliably sync user entries with a local or remote server.
+
+The name "sshyp" is a combination of its syncing library, "sshync", and "passwords".
+
+# WARNING
+It is your responsibility to assess the security and stability of "sshyp" before using it and ensure it meets your needs.
+I am not responsible for any data loss or breaches of your information resulting from the use of "sshyp".
+"sshyp" is a new project that is constantly being updated, and though safety and security are priorities, they cannot be guaranteed.
+
+# Mission Statement
+sshyp aims to make it as simple as possible to manage passwords and notes via CLI across multiple devices in a secure, self-hosted fashion.
+
+What sshyp can do:
+
+- securely manage a collection of encrypted passwords and notes via CLI
+- generate new, secure passwords to the user's choice in length and complexity
+- securely sync said passwords and notes seamlessly between devices
+- utilize [extensions](https://github.com/rwinkhart/sshyp-labs) to interact with your entries is additional ways (such as generating TOTP keys)
+- everything above with entries created by pass/password-store!
+- everything above on Haiku, FreeBSD, Linux, and Termux (an Android terminal emulator)!
+
+What sshyp will likely do:
+
+- (planned v1.2.0) everything it already does, but also in a GUI for Linux/Haiku
+
+What sshyp definitely won't do:
+
+- Non-UNIX(-like) support, e.g. Windows (I'd be happy to link to third-party ports, if someone were to make them)
 
 # Installation
+Please see the [installation guide](https://github.com/rwinkhart/sshyp/wiki/Installation) in the sshyp wiki for directions specific to your distribution/OS.
 
-Arch Linux (x86_64, aarch64)
+Pre-built packages exist for Haiku, FreeBSD, Arch Linux, Debian/Ubuntu Linux, Fedora Linux, and Termux. These can be downloaded from the releases page.
 
-rpass is available in the Arch User Repository as 'rpass'.
+Requests for additional distribution/OS support can be filed as issues.
 
-Install with your preferred AUR helper or use:
+Extensions are available in the [sshyp-labs](https://github.com/rwinkhart/sshyp-labs) repository.
 
-git clone https://aur.archlinux.org/rpass.git
-cd rpass
-makepkg -si
+# Building
+Since sshyp is written entirely in Python, it doesn't need to be compiled. It does, however, need to be packaged for installation.
+
+A packaging script is included in the root directory of the repo in order to package sshyp for your distribution. To package sshyp from source, simply run:
+
+```
+git clone https://github.com/rwinkhart/sshyp.git
+cd sshyp
+./package.sh
+```
+
+The packaging script has been tested on Arch Linux with "dpkg" as a dependency for Debian/Ubuntu and Termux packaging and "freebsd-pkg" as a dependency for FreeBSD packaging.
+
+Haiku and Fedora packaging must be done on their own respective distributions.
+
+The AUR version and the packages attatched to the release tags were already packaged using this script.
+
+Currently, the script can create packages for Haiku, FreeBSD, Arch Linux (PKGBUILD), Debian/Ubuntu Linux, Fedora Linux, Termux, and generic.
+
+# Usage
+Upon initial installation (on both the server and client devices), be sure to run:
+
+```
+sshyp tweak
+```
+
+This command will allow you to configure the settings necessary for sshyp to function. To ensure configuration compatibility, it is a good idea to run 'sshyp tweak' after each major update.
+
+Please note that decrypting and reading entries is disabled on server devices for security reasons. Only devices configured as clients can use the gpg key to decrypt entries.
+
+All available options can be found with:
+
+```
+sshyp --help
+```
+
+Or alternatively, in the manpage:
+
+```
+man sshyp
+```
+
+# Roadmap
+Short-term Goals:
+
+- create minimal GUI app (Linux x86_64, Linux aarch64)
+- various optimizations/bug fixes
+
+Long-term Goals:
+
+- a fun surprise
+- seize the thrones, shear the humans

bin/sshync.py

@@ -0,0 +1,104 @@
+#!/bin/python3
+
+# external modules
+
+from os import path, system, walk
+from os.path import expanduser, getmtime, join
+from pathlib import Path
+from sys import exit as s_exit
+
+
+# utility functions
+
+def get_titles_mods(_directory, _destination, _user_data):  # fetches and returns lists of titles and their mod times
+    _title_list, _mod_list = [], []
+    Path(path.expanduser('~/.config/sshync')).mkdir(0o700, parents=True, exist_ok=True)  # create config directory
+    # local fetching
+    if _destination == 'l':
+        open(expanduser('~/.config/sshync/database'), 'w').write('')  # blanks out database file
+        for _root, _directories, _files in walk(_directory):
+            for _filename in _files:
+                _title_list.append(join(_root.replace(_directory, '', 1), _filename))
+                _mod_list.append(int(getmtime(join(_root, _filename))))
+        for _title in _title_list:
+            open(expanduser('~/.config/sshync/database'), 'a').write(str(_title) + '\n')
+        open(expanduser('~/.config/sshync/database'), 'a').write('^&*\n')
+        for _mod in _mod_list:
+            open(expanduser('~/.config/sshync/database'), 'a').write(str(_mod) + '\n')
+    # remote fetching
+    if _destination == 'r':
+        system(f"ssh -i '{_user_data[5]}' -p {_user_data[2]} {_user_data[0]}@{_user_data[1]} \"cd /bin; python -c 'impo"
+               f"rt sshync; sshync.get_titles_mods(\"'\"{_user_data[4]}\"'\", \"'\"l\"'\", \"'\"{_user_data}\"'\")'\"")
+        system(f"scp -pqs -P {_user_data[2]} -i '{_user_data[5]}' {_user_data[0]}@{_user_data[1]}:"
+               f"'/home/{_user_data[0]}/.config/sshync/database' '{expanduser('~/.config/sshync/')}'")
+        _titles, _sep, _mods = '*&^'.join(open(expanduser('~/.config/sshync/database')).readlines()).replace('\n', '')\
+            .partition('^&*')
+        _title_list, _mod_list = _titles.split('*&^')[:-1], _mods.split('*&^')[1:]
+    return _title_list, _mod_list
+
+
+def sort_titles_mods(_list_1, _list_2):  # creates and returns two lists (of titles and mod times) generated by sorting
+    # information from two different, provided lists
+    _title_list_2_sorted, _mod_list_2_sorted = [], []
+    # title sorting
+    for _title in _list_1[0]:
+        if _title in _list_2[0]:
+            _title_list_2_sorted.append(_title)
+    for _title in _list_2[0]:
+        if _title not in _title_list_2_sorted:
+            _title_list_2_sorted.append(_title)
+    # mod time sorting
+    for _title in _title_list_2_sorted:
+        _mod_list_2_sorted.append(_list_2[1][_list_2[0].index(_title)])
+    return _title_list_2_sorted, _mod_list_2_sorted
+
+
+def make_profile(_profile_dir, _local_dir, _remote_dir, _identity, _ip, _port, _user):  # creates a sshync job profile
+    open(_profile_dir, 'w').write(_user + '\n' + _ip + '\n' + _port + '\n' + _local_dir + '\n' + _remote_dir + '\n' +
+                                  _identity + '\n')
+
+
+def get_profile(_profile_dir):  # returns a list of data read from a sshync job profile
+    try:
+        _profile_data = open(_profile_dir).readlines()
+    except (FileNotFoundError, IndexError):
+        print('\n\u001b[38;5;9merror: the profile does not exist or is corrupted.\u001b[0m\n')
+        _profile_data = None
+        s_exit(1)
+    # extract data from profile
+    _user = _profile_data[0].replace('\n', '')
+    _ip = _profile_data[1].replace('\n', '')
+    _port = _profile_data[2].replace('\n', '')
+    _local_dir = _profile_data[3].replace('\n', '')
+    _remote_dir = _profile_data[4].replace('\n', '')
+    _identity = _profile_data[5].replace('\n', '')
+    return _user, _ip, _port, _local_dir, _remote_dir, _identity
+
+
+def run_profile(_profile_dir):  # runs a sshync job profile
+    _user_data = get_profile(_profile_dir)
+    _remote_titles_mods_saver = get_titles_mods(_user_data[4], 'r', _user_data)  # saved to prevent re-walking directory
+    _index_l = sort_titles_mods(_remote_titles_mods_saver, get_titles_mods(_user_data[3], 'l', _user_data))
+    _index_r = sort_titles_mods(_index_l, _remote_titles_mods_saver)
+    _i = -1
+    for _title in _index_l[0]:
+        _i += 1
+        if _title in _index_r[0]:
+            # compare mod times and sync
+            if int(_index_l[1][_i]) > int(_index_r[1][_i]):
+                print(f"\u001b[38;5;4m{_title[:-4]}\u001b[0m is newer locally, uploading...")
+                system(f"scp -pqs -P {_user_data[2]} -i '{_user_data[5]}' '{_user_data[3]}{_title}' "
+                       f"'{_user_data[0]}@{_user_data[1]}:{_user_data[4]}{'/'.join(_title.split('/')[:-1]) + '/'}'")
+            elif int(_index_l[1][_i]) < int(_index_r[1][_i]):
+                print(f"\u001b[38;5;2m{_title[:-4]}\u001b[0m is newer remotely, downloading...")
+                system(f"scp -pqs -P {_user_data[2]} -i '{_user_data[5]}' '{_user_data[0]}@{_user_data[1]}:"
+                       f"{_user_data[4]}{_title}' '{_user_data[3]}{'/'.join(_title.split('/')[:-1]) + '/'}'")
+        else:
+            print(f"\u001b[38;5;4m{_title[:-4]}\u001b[0m is not on remote server, uploading...")
+            system(f"scp -pqs -P {_user_data[2]} -i '{_user_data[5]}' '{_user_data[3]}{_title}' "
+                   f"'{_user_data[0]}@{_user_data[1]}:{_user_data[4]}{'/'.join(_title.split('/')[:-1]) + '/'}'")
+    for _title in _index_r[0]:
+        if _title not in _index_l[0]:
+            print(f"\u001b[38;5;2m{_title[:-4]}\u001b[0m is not in local directory, downloading...")
+            system(f"scp -pqs -P {_user_data[2]} -i '{_user_data[5]}' '{_user_data[0]}@{_user_data[1]}:"
+                   f"{_user_data[4]}{_title}' '{_user_data[3]}{'/'.join(_title.split('/')[:-1]) + '/'}'")

bin/sshyp.py

@@ -0,0 +1,768 @@
+#!/bin/python3
+
+# external modules
+
+from os import environ, listdir, path, remove, system, uname, walk
+from pathlib import Path
+from random import randint, SystemRandom
+from shutil import get_terminal_size, move, rmtree
+import sshync
+import string
+from subprocess import CalledProcessError, Popen, PIPE, run
+from sys import argv, exit as s_exit
+from textwrap import fill
+
+
+# BELOW - utility functions
+
+def entry_list_gen(_directory=path.expanduser('~/.local/share/sshyp/')):  # generates and prints full entry list
+    print('\n\u001b[38;5;0;48;5;15msshyp entries:\u001b[0m\n')
+    _entry_list, _color_alternator = [], 1
+    for _entry in sorted(listdir(_directory)):
+        if Path(f"{_directory}{_entry}").is_file():
+            if _color_alternator == 1:
+                _entry_list.append(f"{_entry.replace('.gpg', '')}")
+                _color_alternator = 2
+            else:
+                _entry_list.append(f"\u001b[38;5;8m{_entry.replace('.gpg', '')}\u001b[0m")
+                _color_alternator = 1
+    _real = len(' '.join(_entry_list)) - (5.5 * len(_entry_list))
+    if _real <= get_terminal_size()[0]:
+        _width = len(' '.join(_entry_list))
+    else:
+        _width = (len(' '.join(_entry_list)) / (_real / get_terminal_size()[0]) - 25)
+    try:
+        print(fill(' '.join(_entry_list), width=_width) + '\n')
+    except ValueError:
+        pass
+    for _root, _directories, _files in walk(_directory):
+        for _dir in sorted(_directories):
+            _inner_dir = f"{_root.replace(_directory, '')}/{_dir}"
+            print(f"\u001b[38;5;15;48;5;238m{_inner_dir}/\u001b[0m")
+            _entry_list, _color_alternator = [], 1
+            for _s_root, _s_directories, _s_files in walk(f"{_directory[:-1]}{_inner_dir}"):
+                for _entry in sorted(_s_files):
+                    if _color_alternator == 1:
+                        _entry_list.append(f"{_entry.replace('.gpg', '')}")
+                        _color_alternator = 2
+                    else:
+                        _entry_list.append(f"\u001b[38;5;8m{_entry.replace('.gpg', '')}\u001b[0m")
+                        _color_alternator = 1
+            _real = len(' '.join(_entry_list)) - (5.5 * len(_entry_list))
+            if _real <= get_terminal_size()[0]:
+                _width = len(' '.join(_entry_list))
+            else:
+                _width = (len(' '.join(_entry_list)) / (_real / get_terminal_size()[0]) - 25)
+            try:
+                print(fill(' '.join(_entry_list), width=_width) + '\n')
+            except ValueError:
+                print('\u001b[38;5;9m-empty directory-\u001b[0m\n')
+
+
+def entry_reader(_decrypted_entry):  # displays the contents of an entry in a readable format
+    _entry_lines, _notes_flag = open(_decrypted_entry, 'r').readlines(), 0
+    print()
+    for _num in range(len(_entry_lines)):
+        try:
+            if _num == 0 and _entry_lines[1] != '\n':
+                print(f"\u001b[38;5;15;48;5;238musername:\u001b[0m\n{_entry_lines[1].strip()}\n")
+            elif _num == 1 and _entry_lines[0] != '\n':
+                print(f"\u001b[38;5;15;48;5;238mpassword:\u001b[0m\n{_entry_lines[0].strip()}\n")
+            elif _num == 2 and _entry_lines[2] != '\n':
+                print(f"\u001b[38;5;15;48;5;238murl:\u001b[0m\n{_entry_lines[_num].strip()}\n")
+            elif _num >= 3 and _entry_lines[_num] != '\n' and _notes_flag != 1:
+                _notes_flag = 1
+                print(f"\u001b[38;5;15;48;5;238mnotes:\u001b[0m\n{_entry_lines[_num].strip()}")
+            elif _num >= 3 and _notes_flag == 1:
+                print(_entry_lines[_num].replace('\n', ''))
+            if _notes_flag == 1:
+                try:
+                    _line_test = _entry_lines[_num + 1]
+                except IndexError:
+                    print()
+        except IndexError:
+            if _num == 0:
+                print(f"\u001b[38;5;15;48;5;238mpassword:\u001b[0m\n{_entry_lines[0]}\n")
+
+
+def entry_name_fetch(_entry_name_location):  # fetches and returns entry name from user input or from provided argument
+    if type(_entry_name_location) == str:
+        entry_list_gen()
+        _entry_name = str(input(_entry_name_location))
+    else:
+        _entry_name_split = argument.split(' ')
+        del _entry_name_split[:_entry_name_location]
+        _entry_name = ' '.join(_entry_name_split)
+    if _entry_name.startswith('/'):
+        return _entry_name.replace('/', '', 1)
+    else:
+        return _entry_name
+
+
+def shm_gen(_tmp_dir=path.expanduser('~/.config/sshyp/tmp/')):  # creates a temporary directory for entry editing
+    _shm_folder_gen = ''.join(SystemRandom().choice(string.ascii_letters + string.digits)
+                              for _ in range(randint(10, 30)))
+    _shm_entry_gen = ''.join(SystemRandom().choice(string.ascii_letters + string.digits)
+                             for _ in range(randint(10, 30)))
+    Path(_tmp_dir + _shm_folder_gen).mkdir(0o700)
+    return _shm_folder_gen, _shm_entry_gen
+
+
+def pass_gen():  # generates and returns a random password based on user-specified options
+    def _pass_gen_function(__complexity, __length):
+        if __complexity.lower() == 's':
+            __character_pool = string.ascii_letters + string.digits
+        else:
+            __character_pool = string.ascii_letters + string.digits + string.punctuation
+        __gen = ''.join(SystemRandom().choice(__character_pool) for _ in range(__length))
+        __min_special, __special = round(.2 * __length), 0
+        for __character in __gen:
+            if not __character.isalpha():
+                __special += 1
+        if __special < __min_special:
+            __gen = _pass_gen_function(__complexity, __length)
+        return __gen
+    try:
+        _length = int(input('password length: '))
+    except ValueError:
+        print(f"\n\u001b[38;5;9merror: a non-integer value was input for password length\u001b[0m\n")
+        _gen = pass_gen()
+        return _gen
+    if _length > 840:
+        _length = 840
+        print('\n\u001b[38;5;9mpassword length has been limited to the maximum of 840 characters\u001b[0m\n')
+    _complexity = str(input('password complexity - simple (for compatibility) or complex (for security)? (s/C) '))
+    _gen = _pass_gen_function(_complexity, _length)
+    return _gen
+
+
+def encrypt(_entry_dir, _shm_folder, _shm_entry, _gpg_com, _gpg_id, _tmp_dir=path.expanduser('~/.config/sshyp/tmp/')):
+    # encrypts an entry and cleans up the temporary files
+    system(f"{_gpg_com} -qr {str(_gpg_id)} -e '{_tmp_dir}{_shm_folder}/{_shm_entry}'")
+    move(f"{_tmp_dir}{_shm_folder}/{_shm_entry}.gpg", f"{_entry_dir}.gpg")
+    rmtree(f"{_tmp_dir}{_shm_folder}")
+
+
+def decrypt(_entry_dir, _shm_folder, _shm_entry, _gpg_command, _tmp_dir=path.expanduser('~/.config/sshyp/tmp/')):
+    # decrypts an entry to a temporary directory
+    if _shm_folder == 0 and _shm_entry == 0:
+        _command = f"{_gpg_command} -qd --output /dev/null {path.expanduser('~/.config/sshyp/lock.gpg')}"
+    else:
+        _command = f"{_gpg_command} -qd --output {_tmp_dir}{_shm_folder}/{_shm_entry} {_entry_dir}.gpg"
+    try:
+        run(_command, shell=True, stderr=PIPE, check=True, close_fds=True)
+    except CalledProcessError:
+        print(f"\n\u001b[38;5;9merror: could not decrypt - ensure the correct gpg key is present\u001b[0m\n")
+        s_exit(1)
+
+
+def optimized_edit(_lines, _edit_data, _edit_line):  # ensures an edited entry is optimized for best compatibility
+    while len(_lines) < _edit_line + 1:
+        _lines += ['\n']
+    if _edit_data is not None:
+        _lines[_edit_line] = _edit_data.strip('\n').rstrip() + '\n'
+    for _num in range(len(_lines)):
+        if not _lines[_num].endswith('\n'):
+            _lines[_num] += '\n'
+    for _num in reversed(range(len(_lines))):
+        if _lines[_num] == '\n':
+            _lines = _lines[:-1]
+        elif _lines[_num].endswith('\n'):
+            _lines[_num] = _lines[_num].rstrip()
+            break
+        else:
+            break
+    return _lines
+
+
+def edit_note(_shm_folder, _shm_entry, _lines):  # edits the note attached to an entry
+    _reg_lines = _lines[0:3]
+    open(f"{tmp_dir}{_shm_folder}/{_shm_entry}-n", 'w').writelines(_lines[3:])
+    system(f"{editor} {tmp_dir}{_shm_folder}/{_shm_entry}-n")
+    _new_notes = open(f"{tmp_dir}{_shm_folder}/{_shm_entry}-n").readlines()
+    while len(_reg_lines) < 3:
+        _reg_lines += ['\n']
+    _noted_lines = _reg_lines + _new_notes
+    return _noted_lines
+
+
+def copy_name_check(_port, _username_ssh, _ip, _client_device_name):
+    # attempts to connect to the user's server via ssh to register the device for syncing
+    _command = f"ssh -o ConnectTimeout=3 -i '{path.expanduser('~/.ssh/sshyp')}' -p {_port} {_username_ssh}@{_ip} " \
+               f"\"touch '/home/{_username_ssh}/.config/sshyp/devices/{_client_device_name}'\""
+    try:
+        run(_command, shell=True, stderr=PIPE, check=True, close_fds=True)
+    except CalledProcessError:
+        print('\n\u001b[38;5;9mwarning: ssh connection could not be made - ensure the public key (~/.ssh/sshyp.pub) is '
+              'registered on the remote server and that the entered ip, port, and username are correct\n\nsyncing '
+              'functionality will be disabled until this is addressed\u001b[0m\n')
+        open(path.expanduser('~/.config/sshyp/ssh-error'), 'w').write('1')
+        return 1
+    open(path.expanduser('~/.config/sshyp/ssh-error'), 'w').write('0')
+    return 0
+
+# BELOW - argument-specific functions
+
+
+def tweak():  # runs configuration wizard
+    _divider = f"\n{'=' * (get_terminal_size()[0] - int((.5 * get_terminal_size()[0])))}\n\n"
+    # storage/config directory creation
+    Path(path.expanduser('~/.local/share/sshyp')).mkdir(0o700, parents=True, exist_ok=True)
+    Path(path.expanduser('~/.config/sshyp/devices')).mkdir(0o700, parents=True, exist_ok=True)
+    if not Path(f"{path.expanduser('~/.config/sshyp/tmp')}").exists():
+        if uname()[0] == 'Haiku' or uname()[0] == 'FreeBSD':
+            system(f"ln -s /tmp {path.expanduser('~/.config/sshyp/tmp')}")
+        elif Path("/data/data/com.termux").exists():
+            system(f"ln -s '/data/data/com.termux/files/usr/tmp' {path.expanduser('~/.config/sshyp/tmp')}")
+        else:
+            system(f"ln -s /dev/shm {path.expanduser('~/.config/sshyp/tmp')}")
+    # device type configuration
+    _device_type = input('\nclient or server installation? (C/s) ')
+    if _device_type.lower() == 's':
+        open(path.expanduser('~/.config/sshyp/sshyp-device'), 'w').write(_device_type)
+        Path(path.expanduser('~/.config/sshyp/deleted')).mkdir(0o700, parents=True, exist_ok=True)
+        print(f"\n\u001b[4;1mmake sure the ssh service is running and properly configured\u001b[0m\n"
+              f"{_divider}configuration complete\n")
+        s_exit(0)
+    else:
+        # device type configuration
+        _device_type = 'c'  # ensure device type flag is properly set
+        open(path.expanduser('~/.config/sshyp/sshyp-device'), 'w').write(_device_type)
+
+        # gpg configuration
+        _gpg_id = input(f"{_divider}sshyp requires the use of a unique gpg key - use an (e)xisting key or (g)enerate "
+                        f"a new one? (E/g) ")
+        if _gpg_id.lower() != 'g':
+            system(f"{gpg} -k")
+            _gpg_id = str(input('gpg key id: '))
+        else:
+            print('\na unique gpg key is being generated for you...')
+            if not Path(path.expanduser('~/.config/sshyp/gpg-gen')).is_file():
+                open(path.expanduser('~/.config/sshyp/gpg-gen'), 'w').writelines([
+                    'Key-Type: 1\n', 'Key-Length: 4096\n', 'Key-Usage: sign encrypt\n', 'Name-Real: sshyp\n',
+                    'Name-Comment: gpg-sshyp\n', 'Name-Email: https://github.com/rwinkhart/sshyp\n', 'Expire-Date: 0'])
+            if uname()[0] == 'Haiku':
+                run(gpg + ' --batch --generate-key --passphrase ' + "'" +
+                    input('\ngpg passphrase: ') + "'" + " '" +
+                    path.expanduser('~/.config/sshyp/gpg-gen') + "'", shell=True)
+            else:
+                run(f"{gpg} --batch --generate-key '{path.expanduser('~/.config/sshyp/gpg-gen')}'", shell=True)
+            remove(path.expanduser('~/.config/sshyp/gpg-gen'))
+            _gpg_id = run(f"{gpg} -k", shell=True, stdout=PIPE, text=True).stdout.split('\n')[-4].strip()
+
+        # lock file generation
+        if Path(path.expanduser('~/.config/sshyp/lock.gpg')).is_file():
+            remove(path.expanduser('~/.config/sshyp/lock.gpg'))
+        open(path.expanduser('~/.config/sshyp/lock'), 'w')
+        system(f"{gpg} -qr {str(_gpg_id)} -e {path.expanduser('~/.config/sshyp/lock')}")
+        remove(path.expanduser('~/.config/sshyp/lock'))
+
+        # ssh key configuration
+        _ssh_gen = (input(f"{_divider}make sure the ssh service on the remote server is running and properly "
+                          f"configured\n\nsync support requires a unique ssh key - would you like to have this "
+                          f"automatically generated? (Y/n) "))
+        if _ssh_gen.lower() != 'n':
+            if uname()[0] == 'Haiku':
+                Path(f"{path.expanduser('~')}/.ssh").mkdir(0o700, exist_ok=True)
+            system('ssh-keygen -t ed25519 -f ~/.ssh/sshyp')
+        else:
+            print(f"\n\u001b[4;1mensure that the key file you are using is located at "
+                  f"{path.expanduser('~/.ssh/sshyp')}\u001b[0m")
+
+        # ssh ip+port configuration
+        _ip_port = str(input(f"{_divider}example input: 10.10.10.10:9999\n\nip and ssh port of the remote server: "))
+        _ip, _sep, _port = _ip_port.partition(':')
+
+        # ssh user configuration
+        _username_ssh = str(input('\nusername of the remote server: '))
+
+        # sshyp-only data storage
+        open(path.expanduser('~/.config/sshyp/sshyp-data'), 'w')\
+            .write(_gpg_id + '\n' + input(f"{_divider}example input: vim\n\npreferred text editor: "))
+
+        # sshync profile generation
+        sshync.make_profile(path.expanduser('~/.config/sshyp/sshyp.sshync'),
+                            path.expanduser('~/.local/share/sshyp/'), f"/home/{_username_ssh}/.local/share/sshyp/",
+                            path.expanduser('~/.ssh/sshyp'), _ip, _port, _username_ssh)
+
+        # device name configuration
+        for _name in listdir(path.expanduser('~/.config/sshyp/devices')):  # remove existing device name
+            remove(f"{path.expanduser('~/.config/sshyp/devices/')}{_name}")
+        print(f"{_divider}\u001b[4;1mimportant:\u001b[0m this name \u001b[4;1mmust\u001b[0m be unique amongst your "
+              f"client devices\n\nthis is used to keep track of which devices have up-to-date databases\n")
+        _client_device_name = str(input('device name: '))
+        open(f"{path.expanduser('~/.config/sshyp/devices/')}{_client_device_name}", 'w')
+        copy_name_check(_port, _username_ssh, _ip, _client_device_name)
+
+        print(f"{_divider}configuration complete\n")
+
+
+def print_info():  # prints help text based on argument
+    if argument_list[1] == 'help' or argument_list[1] == '--help' or argument_list[1] == '-h':
+        print('\n\u001b[1msshyp  copyright (c) 2021-2022  randall winkhart\u001b[0m\n')
+        print("this is free software, and you are welcome to redistribute it under certain conditions;\nthis program "
+              "comes with absolutely no warranty;\ntype `sshyp license' for details")
+        print('\n\u001b[1musage:\u001b[0m sshyp [option [flag] [<entry name>]] | [/<entry name>]\n')
+        print('\u001b[1moptions:\u001b[0m')
+        print('help/--help/-h           bring up this menu')
+        print('version/-v               display sshyp version info')
+        print('tweak                    configure sshyp')
+        print('add                      add an entry')
+        print('gen                      generate a new password')
+        print('edit                     edit an existing entry')
+        print('copy                     copy details of an entry to your clipboard')
+        print('shear/-rm                delete an existing entry')
+        print('sync/-s                  manually sync the entry directory via sshync\n')
+        print('\u001b[1mflags:\u001b[0m')
+        print('add:')
+        print(' password/-p             add a password entry')
+        print(' note/-n                 add a note entry')
+        print(' folder/-f               add a new folder for entries')
+        print('edit:')
+        print(' rename/relocate/-r      rename or relocate an entry')
+        print(' username/-u             change the username of an entry')
+        print(' password/-p             change the password of an entry')
+        print(' note/-n                 change the note attached to an entry')
+        print(' url/-l                  change the url attached to an entry')
+        print('copy:')
+        print(' username/-u             copy the username of an entry to your clipboard')
+        print(' password/-p             copy the password of an entry to your clipboard')
+        print(' url/-l                  copy the url of an entry to your clipboard')
+        print(' note/-n                 copy the note of an entry to your clipboard')
+        print('gen:')
+        print(' update/-u               generate a password for an existing entry\n')
+        print("\u001b[1mtip:\u001b[0m you can quickly read an entry with 'sshyp /<entry name>'")
+    elif argument_list[1] == 'version' or argument_list[1] == '-v':
+        print('\nsshyp is a simple, self-hosted, sftp-synchronized password manager\nfor unix(-like) systems (haiku/'
+              'freebsd/linux/termux)\n\nsshyp is a viable alternative to (and compatible with) pass/password-store\n')
+        print("                ..       \u001b[38;5;9m♥♥ ♥♥\u001b[0m       ..\n         .''.''/()\\     \u001b[38;5;13m"
+              "♥♥♥♥♥♥♥\u001b[0m     /()\\''.''.\n        *       :        \u001b[38;5;9m♥♥♥♥♥\u001b[0m        :       *"
+              "\n         `..'..'          \u001b[38;5;13m♥♥♥\u001b[0m          `..'..'\n         //   \\\\           "
+              "\u001b[38;5;9m♥\u001b[0m           //   \\\\")
+        print('\u001b[38;5;7;48;5;8m<><><><><><><><><><><><><><><><><><><><><><><><><><><><>\u001b[0m')
+        print('\u001b[38;5;7;48;5;8m/\u001b[38;5;15;48;5;15m                                                      '
+              '\u001b[38;5;7;48;5;8m/\u001b[0m')
+        print('\u001b[38;5;7;48;5;8m/\u001b[38;5;15;48;5;15m   \u001b[38;5;15;48;5;8msshyp  copyright (c) 2021-2022  '
+              'randall winkhart\u001b[38;5;15;48;5;15m   \u001b[38;5;7;48;5;8m/\u001b[0m')
+        print('\u001b[38;5;7;48;5;8m/\u001b[38;5;15;48;5;15m                                                      '
+              '\u001b[38;5;7;48;5;8m/\u001b[0m')
+        print('\u001b[38;5;7;48;5;8m/\u001b[38;5;15;48;5;15m                    \u001b[38;5;15;48;5;8mversion 1.1.1'
+              '\u001b[38;5;15;48;5;15m                     \u001b[38;5;7;48;5;8m/\u001b[0m')
+        print('\u001b[38;5;7;48;5;8m/\u001b[38;5;15;48;5;15m                 \u001b[38;5;15;48;5;8mthe sheecrets '
+              'update\u001b[38;5;15;48;5;15m                 \u001b[38;5;7;48;5;8m/\u001b[0m')
+        print('\u001b[38;5;7;48;5;8m/\u001b[38;5;15;48;5;15m                                                      '
+              '\u001b[38;5;7;48;5;8m/\u001b[0m')
+        print('\u001b[38;5;7;48;5;8m<><><><><><><><><><><><><><><><><><><><><><><><><><><><>\u001b[0m\n')
+        print('see https://github.com/rwinkhart/sshyp for more information\n')
+    elif argument_list[1] == 'license':
+        print('\nThis program is free software: you can redistribute it and/or modify it under the terms of the GNU '
+              'General\nPublic License as published by the Free Software Foundation, either version 3 of the License,'
+              '\nor (at your option) any later version.\n\nThis program is distributed in the hope that it will be '
+              'useful, but WITHOUT ANY WARRANTY;\nwithout even the implied warranty of MERCHANTABILITY or FITNESS FOR A'
+              ' PARTICULAR PURPOSE.\nSee the GNU General Public License for more details.'
+              '\n\nhttps://opensource.org/licenses/GPL-3.0\n')
+    elif argument_list[1] == 'add':
+        print('\n\u001b[1musage:\u001b[0m sshyp add [flag [<entry name>]]\u001b[0m\n')
+        print('\u001b[1mflags:\u001b[0m')
+        print('add:')
+        print(' password/-p             add a password entry')
+        print(' note/-n                 add a note entry')
+        print(' folder/-f               add a new folder for entries\n')
+    elif argument_list[1] == 'edit':
+        print('\n\u001b[1musage:\u001b[0m sshyp edit [flag [<entry name>]]\u001b[0m\n')
+        print('\u001b[1mflags:\u001b[0m')
+        print('edit:')
+        print(' rename/relocate/-r      rename or relocate an entry')
+        print(' username/-u             change the username of an entry')
+        print(' password/-p             change the password of an entry')
+        print(' url/-l                  change the url attached to an entry')
+        print(' note/-n                 change the note attached to an entry\n')
+    elif argument_list[1] == 'copy':
+        print('\n\u001b[1musage:\u001b[0m sshyp copy [flag [<entry name>]]\u001b[0m\n')
+        print('\u001b[1mflags:\u001b[0m')
+        print('copy:')
+        print(' username/-u             copy the username of an entry to your clipboard')
+        print(' password/-p             copy the password of an entry to your clipboard')
+        print(' url/-l                  copy the url of an entry to your clipboard')
+        print(' note/-n                 copy the note of an entry to your clipboard\n')
+
+
+def no_arg():  # displays a list of entries and gives an option to select one for viewing
+    print("\nfor a list of usable commands, run 'sshyp help'")
+    _entry_name = entry_name_fetch('entry to read: ')
+    if not Path(f"{directory}{_entry_name}.gpg").exists():
+        print(f"\n\u001b[38;5;9merror: entry ({_entry_name}) does not exist\u001b[0m\n")
+        s_exit(1)
+    _shm_folder, _shm_entry = shm_gen()
+    decrypt(directory + _entry_name, _shm_folder, _shm_entry, gpg)
+    entry_reader(f"{tmp_dir}{_shm_folder}/{_shm_entry}")
+    rmtree(f"{tmp_dir}{_shm_folder}")
+
+
+def read_shortcut():  # shortcut to quickly read an entry
+    if not Path(f"{directory}{argument.replace('/', '', 1)}.gpg").exists():
+        print(f"\n\u001b[38;5;9merror: entry ({argument.replace('/', '', 1)}) does not exist\u001b[0m\n")
+        s_exit(1)
+    _shm_folder, _shm_entry = shm_gen()
+    decrypt(directory + argument.replace('/', '', 1), _shm_folder, _shm_entry, gpg)
+    entry_reader(f"{tmp_dir}{_shm_folder}/{_shm_entry}")
+    rmtree(f"{tmp_dir}{_shm_folder}")
+
+
+def sync():  # calls sshync to sync changes to the user's server
+    print('\nsyncing entries with the server device...\n')
+    # check for deletions
+    system(f"ssh -i '{path.expanduser('~/.ssh/sshyp')}' -p {port} {username_ssh}@{ip} \"cd /bin; python -c "
+           f"'import sshypRemote; sshypRemote.deletion_check(\"'\"{client_device_name}\"'\")'\"")
+    system(f"scp -pqs -P {port} -i '{path.expanduser('~/.ssh/sshyp')}' {username_ssh}@{ip}:'/home/{username_ssh}"
+           f"/.config/sshyp/deletion_database' {path.expanduser('~/.config/sshyp/')}")
+    try:
+        _deletion_database = open(path.expanduser('~/.config/sshyp/deletion_database')).readlines()
+    except (FileNotFoundError, IndexError):
+        print('\n\u001b[38;5;9merror: the deletion database does not exist or is corrupted\u001b[0m\n')
+        _deletion_database = None
+        s_exit(1)
+    for _file in _deletion_database:
+        if _file[:-1].endswith('/'):
+            try:
+                if silent_sync != 1:
+                    print(f"\u001b[38;5;208m{_file[:-1]}\u001b[0m has been sheared, removing...")
+                rmtree(f"{directory}{_file[:-1]}")
+            except FileNotFoundError:
+                if silent_sync != 1:
+                    print('folder does not exist locally.')
+        else:
+            try:
+                if silent_sync != 1:
+                    print(f"\u001b[38;5;208m{_file[:-1]}\u001b[0m has been sheared, removing...")
+                remove(f"{directory}{_file[:-1]}.gpg")
+            except (FileNotFoundError, IsADirectoryError):
+                if silent_sync != 1:
+                    print('file does not exist locally.')
+    # check for new folders
+    system(f"ssh -i '{path.expanduser('~/.ssh/sshyp')}' -p {port} {username_ssh}@{ip} \"cd /bin; python -c "
+           f"'import sshypRemote; sshypRemote.folder_check()'\"")
+    system(f"scp -pqs -P {port} -i '{path.expanduser('~/.ssh/sshyp')}' {username_ssh}@{ip}:'/home/{username_ssh}"
+           f"/.config/sshyp/folder_database' {path.expanduser('~/.config/sshyp/')}")
+    try:
+        _folder_database = open(path.expanduser('~/.config/sshyp/folder_database')).readlines()
+    except (FileNotFoundError, IndexError):
+        print('\n\u001b[38;5;9merror: the folder database does not exist or is corrupted\u001b[0m\n')
+        _folder_database = None
+        s_exit(1)
+    for _folder in _folder_database:
+        if Path(f"{path.expanduser('~')}{_folder[:-1]}").is_dir():
+            pass
+        else:
+            print(f"\u001b[38;5;2m{_folder.replace('/.local/share/sshyp/', '')[:-1]}/\u001b[0m does not exist locally, "
+                  f"creating...")
+            Path(f"{path.expanduser('~')}{_folder[:-1]}").mkdir(0o700, parents=True, exist_ok=True)
+    # set permissions before uploading
+    system('find ' + directory + ' -type d -exec chmod -R 700 {} +')
+    system('find ' + directory + ' -type f -exec chmod -R 600 {} +')
+    sshync.run_profile(path.expanduser('~/.config/sshyp/sshyp.sshync'))
+
+
+def add_entry():  # adds a new entry
+    _shm_folder, _shm_entry = None, None  # sets base-line values to avoid errors
+    if len(argument_list) < 4:
+        _entry_name = entry_name_fetch('name of new entry: ')
+    else:
+        _entry_name = entry_name_fetch(2)
+    if Path(f"{directory}{_entry_name}.gpg").is_file():
+        print(f"\n\u001b[38;5;9merror: entry ({_entry_name}) already exists\u001b[0m\n")
+        s_exit(1)
+    if argument_list[2] == 'note' or argument_list[2] == '-n':
+        _shm_folder, _shm_entry = shm_gen()
+        system(f"{editor} {tmp_dir}{_shm_folder}/{_shm_entry}-n")
+        _notes = open(f"{tmp_dir}{_shm_folder}/{_shm_entry}-n", 'r').read()
+        open(f"{tmp_dir}{_shm_folder}/{_shm_entry}", 'w').writelines(optimized_edit(['', '', '', _notes], None, -1))
+    elif argument_list[2] == 'password' or argument_list[2] == '-p':
+        _username = str(input('username: '))
+        _password = str(input('password: '))
+        _url = str(input('url: '))
+        _add_note = input('add a note to this entry? (y/N) ')
+        _shm_folder, _shm_entry = shm_gen()
+        if _add_note.lower() == 'y':
+            system(f"{editor} {tmp_dir}{_shm_folder}/{_shm_entry}-n")
+            _notes = open(f"{tmp_dir}{_shm_folder}/{_shm_entry}-n", 'r').read()
+        else:
+            _notes = ''
+        open(f"{tmp_dir}{_shm_folder}/{_shm_entry}", 'w')\
+            .writelines(optimized_edit([_password, _username, _url, _notes], None, -1))
+    print('\n\u001b[1mentry preview:\u001b[0m')
+    entry_reader(f"{tmp_dir}{_shm_folder}/{_shm_entry}")
+    encrypt(directory + _entry_name, _shm_folder, _shm_entry, gpg, gpg_id)
+
+
+def add_folder():  # creates a new folder
+    if len(argument_list) < 4:
+        _entry_name = entry_name_fetch('name of new folder: ')
+    else:
+        _entry_name = entry_name_fetch(2)
+    Path(directory + _entry_name).mkdir(0o700)
+    system(f"ssh -i '{path.expanduser('~/.ssh/sshyp')}' -p {port} {username_ssh}@{ip} \"mkdir -p '{directory_ssh}"
+           f"{_entry_name}'\"")
+
+
+def rename():  # renames an entry or folder
+    if argument == 'edit rename' or argument == 'edit relocate' or argument == 'edit -r':
+        _entry_name = entry_name_fetch('entry/folder to rename/relocate: ')
+    else:
+        _entry_name = entry_name_fetch(2)
+    if not Path(f"{directory}{_entry_name}.gpg").is_file() and not Path(f"{directory}{_entry_name}").is_dir():
+        print(f"\n\u001b[38;5;9merror: entry ({_entry_name}) does not exist\u001b[0m\n")
+        s_exit(1)
+    _new_name = str(input('new name: '))
+    print(f"{directory}{_new_name}")
+    if Path(f"{directory}{_new_name}.gpg").is_file() or Path(f"{directory}{_new_name}").is_dir():
+        print(f"\n\u001b[38;5;9merror: ({_new_name}) already exists\u001b[0m\n")
+        s_exit(1)
+    if _entry_name.endswith('/'):
+        move(f"{directory}{_entry_name}", f"{directory}{_new_name}")
+        system(f"ssh -i '{path.expanduser('~/.ssh/sshyp')}' -p {port} {username_ssh}@{ip} \"mkdir -p '{directory_ssh}"
+               f"{_new_name}'\"")
+    else:
+        move(f"{directory}{_entry_name}.gpg", f"{directory}{_new_name}.gpg")
+    system(f"ssh -i '{path.expanduser('~/.ssh/sshyp')}' -p {port} {username_ssh}@{ip} \"cd /bin; python -c "
+           f"'import sshypRemote; sshypRemote.delete(\"'\"{_entry_name}\"'\")'\"")
+
+
+def edit():  # edits the contents of an entry
+    _shm_folder, _shm_entry, _detail, _edit_line = None, None, None, None  # sets values to avoid PEP8 warnings
+    if len(argument_list) < 4:
+        _entry_name = entry_name_fetch('entry to edit: ')
+    else:
+        _entry_name = entry_name_fetch(2)
+    if not Path(f"{directory}{_entry_name}.gpg").is_file():
+        print(f"\n\u001b[38;5;9merror: entry ({_entry_name}) does not exist\u001b[0m\n")
+        s_exit(1)
+    _shm_folder, _shm_entry = shm_gen()
+    decrypt(directory + _entry_name, _shm_folder, _shm_entry, gpg)
+    if argument_list[2] == 'username' or argument_list[2] == '-u':
+        _detail, _edit_line = str(input('username: ')), 1
+    elif argument_list[2] == 'password' or argument_list[2] == '-p':
+        _detail, _edit_line = str(input('password: ')), 0
+    elif argument_list[2] == 'url' or argument_list[2] == '-l':
+        _detail, _edit_line = str(input('url: ')), 2
+    if argument_list[2] == 'note' or argument_list[2] == '-n':
+        _edit_line = 2
+        _new_lines = optimized_edit(edit_note(_shm_folder, _shm_entry,
+                                              open(f"{tmp_dir}{_shm_folder}/{_shm_entry}", 'r').readlines()), None, -1)
+    else:
+        _new_lines = optimized_edit(open(f"{tmp_dir}{_shm_folder}/{_shm_entry}", 'r').readlines(), _detail, _edit_line)
+    open(f"{tmp_dir}{_shm_folder}/{_shm_entry}", 'w').writelines(_new_lines)
+    remove(f"{directory}{_entry_name}.gpg")
+    print('\n\u001b[1mentry preview:\u001b[0m')
+    entry_reader(f"{tmp_dir}{_shm_folder}/{_shm_entry}")
+    encrypt(directory + _entry_name, _shm_folder, _shm_entry, gpg, gpg_id)
+
+
+def gen():  # generates a password for a new or an existing entry
+    _username, _url, _notes = None, None, None  # sets base-line values to avoid errors
+    if argument == 'gen update' or argument == 'gen -u' or argument == 'gen':
+        _entry_name = entry_name_fetch('name of entry: ')
+    elif argument_list[2] == 'update' or argument_list[2] == '-u':
+        _entry_name = entry_name_fetch(2)
+        if not Path(f"{directory}{_entry_name}.gpg").is_file():
+            print(f"\n\u001b[38;5;9merror: entry ({_entry_name}) does not exist\u001b[0m\n")
+            s_exit(1)
+    else:
+        _entry_name = entry_name_fetch(1)
+    if len(argument_list) == 2 or (not argument_list[2] == 'update' and not argument_list[2] == '-u'):
+        if Path(f"{directory}{_entry_name}.gpg").is_file():
+            print(f"\n\u001b[38;5;9merror: entry ({_entry_name}) already exists\u001b[0m\n")
+            s_exit(1)
+        _username = str(input('username: '))
+        _password = pass_gen()
+        _url = str(input('url: '))
+        _add_note = input('add a note to this entry? (y/N) ')
+        _shm_folder, _shm_entry = shm_gen()
+        if _add_note.lower() == 'y':
+            system(f"{editor} {tmp_dir}{_shm_folder}/{_shm_entry}-n")
+            _notes = open(f"{tmp_dir}{_shm_folder}/{_shm_entry}-n", 'r').read()
+        else:
+            _notes = ''
+        open(f"{tmp_dir}{_shm_folder}/{_shm_entry}", 'w')\
+            .writelines(optimized_edit([_password, _username, _url, _notes], None, -1))
+    else:
+        _shm_folder, _shm_entry = shm_gen()
+        decrypt(directory + _entry_name, _shm_folder, _shm_entry, gpg)
+        _new_lines = optimized_edit(open(f"{tmp_dir}{_shm_folder}/{_shm_entry}", 'r').readlines(), pass_gen(), 0)
+        open(f"{tmp_dir}{_shm_folder}/{_shm_entry}", 'w').writelines(_new_lines)
+        remove(f"{directory}{_entry_name}.gpg")
+    print('\n\u001b[1mentry preview:\u001b[0m')
+    entry_reader(f"{tmp_dir}{_shm_folder}/{_shm_entry}")
+    encrypt(directory + _entry_name, _shm_folder, _shm_entry, gpg, gpg_id)
+
+
+def copy_data():  # copies a specified field of an entry to the clipboard
+    if len(argument_list) < 4:
+        _entry_name = entry_name_fetch('entry to copy: ')
+    else:
+        _entry_name = entry_name_fetch(2)
+    if not Path(f"{directory}{_entry_name}.gpg").is_file():
+        print(f"\n\u001b[38;5;9merror: entry ({_entry_name}) does not exist\u001b[0m\n")
+        s_exit(1)
+    _shm_folder, _shm_entry = shm_gen()
+    decrypt(directory + _entry_name, _shm_folder, _shm_entry, gpg)
+    _copy_line = open(f"{tmp_dir}{_shm_folder}/{_shm_entry}", 'r').readlines()
+    if uname()[0] == 'Haiku':  # Haiku clipboard detection
+        if argument_list[2] == 'username' or argument_list[2] == '-u':
+            system('clipboard -c ' + "'" + _copy_line[1].replace('\n', '').replace("'", "'\\''") + "'")
+        elif argument_list[2] == 'password' or argument_list[2] == '-p':
+            system('clipboard -c ' + "'" + _copy_line[0].replace('\n', '').replace("'", "'\\''") + "'")
+        elif argument_list[2] == 'url' or argument_list[2] == '-l':
+            system('clipboard -c ' + "'" + _copy_line[2].replace('\n', '').replace("'", "'\\''") + "'")
+        elif argument_list[2] == 'note' or argument_list[2] == '-n':
+            system('clipboard -c ' + "'" + _copy_line[3].replace('\n', '').replace("'", "'\\''") + "'")
+        Popen('sleep 30; clipboard -r', shell=True, close_fds=True)
+    elif Path("/data/data/com.termux").exists():  # Termux (Android) clipboard detection
+        if argument_list[2] == 'username' or argument_list[2] == '-u':
+            system('termux-clipboard-set ' + "'" + _copy_line[1].replace('\n', '').replace("'", "'\\''") + "'")
+        elif argument_list[2] == 'password' or argument_list[2] == '-p':
+            system('termux-clipboard-set ' + "'" + _copy_line[0].replace('\n', '').replace("'", "'\\''") + "'")
+        elif argument_list[2] == 'url' or argument_list[2] == '-l':
+            system('termux-clipboard-set ' + "'" + _copy_line[2].replace('\n', '').replace("'", "'\\''") + "'")
+        elif argument_list[2] == 'note' or argument_list[2] == '-n':
+            system('termux-clipboard-set ' + "'" + _copy_line[3].replace('\n', '').replace("'", "'\\''") + "'")
+        Popen("sleep 30; termux-clipboard-set ''", shell=True, close_fds=True)
+    elif environ.get('WAYLAND_DISPLAY') == 'wayland-0':  # Wayland clipboard detection
+        if argument_list[2] == 'username' or argument_list[2] == '-u':
+            system('wl-copy ' + "'" + _copy_line[1].replace('\n', '').replace("'", "'\\''") + "'")
+        elif argument_list[2] == 'password' or argument_list[2] == '-p':
+            system('wl-copy ' + "'" + _copy_line[0].replace('\n', '').replace("'", "'\\''") + "'")
+        elif argument_list[2] == 'url' or argument_list[2] == '-l':
+            system('wl-copy ' + "'" + _copy_line[2].replace('\n', '').replace("'", "'\\''") + "'")
+        elif argument_list[2] == 'note' or argument_list[2] == '-n':
+            system('wl-copy ' + "'" + _copy_line[3].replace('\n', '').replace("'", "'\\''") + "'")
+        Popen('sleep 30; wl-copy -c', shell=True, close_fds=True)
+    else:  # X11 clipboard detection
+        if argument_list[2] == 'username' or argument_list[2] == '-u':
+            system('echo -n ' + "'" + _copy_line[1].replace('\n', '').replace("'", "'\\''") + "'" + ' | xclip -sel c')
+        elif argument_list[2] == 'password' or argument_list[2] == '-p':
+            system('echo -n ' + "'" + _copy_line[0].replace('\n', '').replace("'", "'\\''") + "'" + ' | xclip -sel c')
+        elif argument_list[2] == 'url' or argument_list[2] == '-l':
+            system('echo -n ' + "'" + _copy_line[2].replace('\n', '').replace("'", "'\\''") + "'" + ' | xclip -sel c')
+        elif argument_list[2] == 'note' or argument_list[2] == '-n':
+            system('echo -n ' + "'" + _copy_line[3].replace('\n', '').replace("'", "'\\''") + "'" + ' | xclip -sel c')
+        Popen("sleep 30; echo -n '' | xclip -sel c", shell=True, close_fds=True)
+    rmtree(f"{tmp_dir}{_shm_folder}")
+
+
+def remove_data():  # deletes an entry from the server and flags it for local deletion on sync
+    if argument == 'shear' or argument == '-rm':
+        _entry_name = entry_name_fetch('entry/folder to shear: ')
+    else:
+        _entry_name = entry_name_fetch(1)
+    decrypt(path.expanduser('~/.config/sshyp/lock.gpg'), 0, 0, gpg)
+    system(f"ssh -i '{path.expanduser('~/.ssh/sshyp')}' -p {port} {username_ssh}@{ip} \"cd /bin; python -c "
+           f"'import sshypRemote; sshypRemote.delete(\"'\"{_entry_name}\"'\")'\"")
+
+
+if __name__ == "__main__":
+    try:
+        silent_sync, ssh_error = 0, 0
+        # retrieve typed argument
+        argument_list = argv
+        argument = ' '.join(argument_list[1:])
+        if uname()[0] == 'Haiku':  # set proper gpg command for OS
+            gpg = 'gpg --pinentry-mode loopback'
+        else:
+            gpg = 'gpg'
+
+        # import saved userdata
+        if argument != 'tweak':
+            device_type = ''
+            tmp_dir = path.expanduser('~/.config/sshyp/tmp/')
+            try:
+                device_type = open(path.expanduser('~/.config/sshyp/sshyp-device')).read().strip()
+                if device_type == 'c':
+                    ssh_info = sshync.get_profile(path.expanduser('~/.config/sshyp/sshyp.sshync'))
+                    username_ssh = ssh_info[0].replace('\n', '')
+                    ip = ssh_info[1].replace('\n', '')
+                    port = ssh_info[2].replace('\n', '')
+                    directory = str(ssh_info[3].replace('\n', ''))
+                    directory_ssh = str(ssh_info[4].replace('\n', ''))
+                    client_device_name = listdir(path.expanduser('~/.config/sshyp/devices'))[0]
+                    sshyp_data = open(path.expanduser('~/.config/sshyp/sshyp-data')).readlines()
+                    gpg_id = sshyp_data[0].replace('\n', '')
+                    editor = sshyp_data[1].replace('\n', '')
+                    ssh_error = int(open(path.expanduser('~/.config/sshyp/ssh-error')).read().strip())
+                    if ssh_error != 0:
+                        ssh_error = copy_name_check(port, username_ssh, ip, client_device_name)
+                else:
+                    print('running as server, option disabled')
+                    s_exit(0)
+            except (FileNotFoundError, IndexError):
+                if device_type.lower() != 's':
+                    print('\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
+                    print("not all necessary configuration files are present - please run 'sshyp tweak'")
+                    print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n')
+                s_exit(1)
+        else:
+            tweak()
+            s_exit(0)
+
+        # run function based on arguments
+        if argument.startswith('/'):
+            read_shortcut()
+        elif argument == '':
+            no_arg()
+        elif argument == 'help' or argument == '--help' or argument == '-h' or argument == 'license' or argument \
+                == 'version' or argument == '-v':
+            print_info()
+        elif argument_list[1] == 'add':
+            if len(argument_list) == 2:
+                print_info()
+            elif argument_list[2] == 'note' or argument_list[2] == '-n' or argument_list[2] == 'password' or \
+                    argument_list[2] == '-p':
+                add_entry()
+            elif argument_list[2] == 'folder' or argument_list[2] == '-f':
+                add_folder()
+            else:
+                print_info()
+                s_exit(0)
+        elif argument_list[1] == 'edit':
+            if len(argument_list) == 2:
+                print_info()
+            elif argument_list[2] == 'rename' or argument_list[2] == 'relocate' or argument_list[2] == '-r':
+                silent_sync = 1
+                rename()
+            elif argument_list[2] == 'username' or argument_list[2] == '-u' or argument_list[2] == 'password' or \
+                    argument_list[2] == '-p' or argument_list[2] == 'url' or argument_list[2] == '-l' or \
+                    argument_list[2] == 'note' or argument_list[2] == '-n':
+                edit()
+            else:
+                print_info()
+                s_exit(0)
+        elif argument_list[1] == 'gen':
+            gen()
+        elif argument_list[1] == 'copy':
+            if len(argument_list) == 2:
+                print_info()
+            elif argument_list[2] == 'username' or argument_list[2] == '-u' or argument_list[2] == 'password' or \
+                    argument_list[2] == '-p' or argument_list[2] == 'url' or argument_list[2] == '-l' or \
+                    argument_list[2] == 'note' or argument_list[2] == '-n':
+                copy_data()
+            else:
+                print_info()
+        elif argument_list[1] == 'shear' or argument_list[1] == '-rm':
+            remove_data()
+        elif argument_list[1] != 'sync' and argument_list[1] != '-s':
+            print(f"\n\u001b[38;5;9merror: invalid argument - run 'sshyp help' to list usable commands\u001b[0m\n")
+            s_exit(1)
+
+        # sync if any changes were made
+        if len(argument_list) > 1 and ssh_error == 0 and \
+                ((argument_list[1] == 'sync' or argument_list[1] == '-s' or argument_list[1] == 'gen' or
+                  argument_list[1] == 'shear' or argument_list[1] == '-rm') or ((argument_list[1] == 'add'
+                                                                                 or argument_list[1] == 'edit')
+                                                                                and len(argument_list) > 2)):
+            sync()
+
+        s_exit(0)
+
+    except KeyboardInterrupt:
+        print('\n')
+        s_exit(0)

bin/sshypRemote.py

@@ -0,0 +1,45 @@
+#!/bin/python3
+
+# external modules
+
+from os import listdir, remove, walk
+from os.path import expanduser
+from shutil import rmtree
+
+
+# utility functions
+
+def delete(_file_path):  # deletes an entry or folder, should be run remotely via ssh
+    if _file_path.endswith('/'):
+        try:
+            rmtree(f"{expanduser('~/.local/share/sshyp/')}{_file_path}")
+        except FileNotFoundError:
+            print('folder does not exist remotely')
+    else:
+        try:
+            remove(f"{expanduser('~/.local/share/sshyp/')}{_file_path}.gpg")
+        except FileNotFoundError:
+            print('file does not exist remotely')
+    for _device_name in listdir(expanduser('~/.config/sshyp/devices')):
+        open(f"{expanduser('~/.config/sshyp/deleted/')}{_file_path.replace('/', '@')}^&*{_device_name}", 'w')
+
+
+def deletion_check(_client_device_name):  # creates a list of entries and folders to be deleted from a local machine
+    open(expanduser('~/.config/sshyp/deletion_database'), 'w').write('')
+    for _file in listdir(expanduser('~/.config/sshyp/deleted')):
+        _file_path = _file.replace('@', '/').split('^&*')[0]
+        _device = _file.split('^&*')[1]
+        if _device == _client_device_name:
+            try:
+                remove(f"{expanduser('~/.config/sshyp/deleted/')}{_file}")
+            except FileNotFoundError:
+                pass
+            open(expanduser('~/.config/sshyp/deletion_database'), 'a').write(_file_path + '\n')
+
+
+def folder_check():  # creates a list of folders to be compared with those of a local machine
+    open(expanduser('~/.config/sshyp/folder_database'), 'w').write('')
+    for _root, _directories, _files in walk(expanduser('~/.local/share/sshyp')):
+        for _dir in _directories:
+            open(expanduser('~/.config/sshyp/folder_database'), 'a')\
+                .write(f"{_root.replace(expanduser('~'), '')}/{_dir}\n")

extra/manpage

@@ -0,0 +1,91 @@
+.TH sshyp 1 "21 July 2022" "v1.1.1" "sshyp man page"
+.SH NAME
+sshyp \- A very simple self-hosted, synchronized password manager for UNIX(-like) systems. Alternative to (and compatible with) pass/password-store.
+.SH SYNOPSIS
+sshyp [OPTION] [[FLAG]] [/<entry name>]
+.SH DESCRIPTION
+sshyp is a lightweight password and note management program written in Python. sshyp is used via CLI and is self-hosted with a client-server model. sshyp expects that you have access to a personal server with a properly configured ssh server, ideally accepting remote connections.
+.SH EXAMPLES
+Setting up sshyp for the first time or altering its configuration (also recommended after major updates):
+    sshyp tweak
+
+Viewing the entry database:
+    sshyp
+
+Reading an existing entry saved as ~/.local/share/sshyp/development/github.gpg:
+    sshyp /development/github
+
+Copying the password of an existing entry saved as ~/.local/share/sshyp/financial/bank.gpg:
+    sshyp copy -p /financial/bank
+
+Editing the username of an existing entry saved as ~/.local/share/sshyp/game.gpg:
+    sshyp edit -u game
+
+Making a new entry saved as ~/.local/share/sshyp/school/university.gpg using the built-in password generator:
+    sshyp gen /school/university
+
+Creating a note-only entry saved as ~/.local/share/sshyp/notes/testNote.gpg:
+    sshyp add -n /notes/testNote
+
+Manually syncing entries with the server:
+    sshyp sync
+
+Removing an existing folder saved as ~/.local/share/sshyp/social:
+    sshyp shear social/
+
+.SH OPTIONS
+USAGE: sshyp [OPTION [FLAG] [<entry name>]] | [/<entry name>]
+
+ help/--help/-h           bring up the help menu
+ version/-v               display sshyp version info
+ tweak                    configure sshyp
+ add                      add an entry
+ gen                      generate a new password
+ edit                     edit an existing entry
+ copy                     copy details of an entry to your clipboard
+ shear/-rm                delete an existing entry
+ sync/-s                  manually sync the entry directory via sshync
+.SH FLAGS
+add:
+ password/-p             add a password entry
+ note/-n                 add a note entry
+ folder/-f               add a new folder for entries
+edit:
+ rename/relocate/-r      rename or relocate an entry
+ username/-u             change the username of an entry
+ password/-p             change the password of an entry
+ note/-n                 change the note attached to an entry
+ url/-l                  change the url attached to an entry
+copy:
+ username/-u             copy the username of an entry to your clipboard
+ password/-p             copy the password of an entry to your clipboard
+ url/-l                  copy the URL of an entry to your clipboard
+ note/-n                 copy the note of an entry to your clipboard
+gen:
+ update/-u               generate a password for an existing entry
+.SH LIMITATIONS
+The following characters/character sequences are not supported in entry/folder titles:
+
+    @   ^&*   *&^
+.SH SETUP
+sshyp operates on a client-server model, and thus requires you to have access to your own server (whether it be a physical home server or a cloud rental) with remote access via SSH.
+
+The sshyp package includes modes for operating on both client and server devices, so only one package is necessary.
+
+Server setup:
+    Configure an OpenSSH server (if sshyp was installed from the Debian package, the ssh server was not installed as a dependency and needs to be installed manually)
+    Allow remote access to the SSH server w/public key authentication (disabling password-only authentication recommended)
+    Install sshyp
+    Run "sshyp tweak" and set the device type as server
+    Done!
+
+Client setup:
+    Install sshyp
+    Run "sshyp tweak" and follow the prompts
+    Copy the generated public SSH key (located at ~/.ssh/sshyp.pub) to the server using preferred method (manually adding to authorized_keys, ssh-copy-id, etc.)
+    If you already have entries on the server, sync them using "sshyp sync"
+    Done!
+
+Please note that the server setup intentionally does not allow the reading of entries (it does not allow adding a gpg decryption key). For security purposes, only clients can read entries.
+.SH AUTHOR
+Randall Winkhart (https://github.com/rwinkhart)

package.sh

@@ -0,0 +1,247 @@
+#!/bin/bash
+
+# This script packages sshyp (from source) for various UNIX(-like) environments.
+# Dependencies (Arch Linux): dpkg (packaging for Debian/Termux), freebsd-pkg (packaging for FreeBSD)
+# Dependencies (Fedora) (can only package for self): rpmdevtools
+# NOTE It is recommended to instead use the latest officially packaged and tagged release.
+
+echo -e '\nOptions (please enter the number only):'
+echo -e '\nPackage Formats:\n\n1. Haiku\n2. Debian&Ubuntu Linux\n3. Fedora Linux\n4. FreeBSD\n5. Termux\n6. Generic (used for PKGBUILD/APKBUILD)'
+echo -e '\nBuild Scripts:\n\n7. Arch Linux (PKGBUILD)'
+echo -e '\nOther:\n\n8. All (generates all distribution packages (excluding Haiku and Fedora, as these must be packaged on their respective distributions) and build scripts)\n'
+read -n 1 -r -p "Distribution: " distro
+
+echo -e '\n\nThe value entered in this field will only affect the version reported to the package manager. The latest source is used regardless.\n'
+read -r -p "Version number: " version
+
+echo -e '\nThe value entered in this field will only affect the revision number for build scripts.\n'
+read -r -p "Revision number: " revision
+
+if [ "$distro" == "7" ] || [ "$distro" == "8" ]; then
+    echo -e '\nOptions (please enter the number only):'
+    echo -e '\n1. GitHub Release Tag\n2. Local\n'
+    read -r -p "Source (for build scripts): " source
+
+    if [ "$source" == "1" ]; then
+        source='https://github.com/rwinkhart/sshyp/releases/download/v$pkgver/sshyp-$pkgver.tar.xz'
+    else
+        source=local://sshyp-"$version".tar.xz
+    fi
+fi
+
+mkdir -p packages
+
+if [ "$distro" == "1" ]; then
+    echo -e '\nPackaging for Haiku...\n'
+    mkdir -p packages/haikutemp/documentation/{man/man1,packages/sshyp}
+    echo "name			sshyp
+version			"$version"-"$revision"
+architecture		any
+summary			\"A light-weight, self-hosted, synchronized password manager\"
+description		\"sshyp is the only password-store compatible CLI password manager available for Haiku - it is also available on Linux/Android (via Termux) so that you can sync your entries across all of your devices.\"
+packager		\"Randall Winkhart <idgr at tutanota dot com>\"
+vendor			\"Randall Winkhart\"
+licenses {
+	\"GNU GPL v3\"
+}
+copyrights {
+	\"2021-2022 Randall Winkhart\"
+}
+provides {
+	sshyp = "$version"
+	cmd:sshyp
+}
+requires {
+	gnupg
+	openssh
+	python3
+}
+urls {
+	\"https://github.com/rwinkhart/sshyp\"
+}
+" > packages/haikutemp/.PackageInfo
+    cp -r bin packages/haikutemp/
+    ln -s /bin/sshyp.py packages/haikutemp/bin/sshyp
+    cp -r share/doc/sshyp/ packages/haikutemp/documentation/packages/
+    cp -r share/licenses/sshyp/ packages/haikutemp/documentation/packages/
+    cp extra/manpage packages/haikutemp/documentation/man/man1/sshyp.1
+    gzip packages/haikutemp/documentation/man/man1/sshyp.1
+    cd packages/haikutemp
+    package create -b sshyp-"$version"-"$revision"_all.hpkg
+    package add sshyp-"$version"-"$revision"_all.hpkg bin documentation
+    cd ../..
+    mv packages/haikutemp/sshyp-"$version"-"$revision"_all.hpkg packages/
+    rm -rf packages/haikutemp
+    echo -e "\nHaiku packaging complete.\n"
+fi
+
+if [ "$distro" == "2" ] || [ "$distro" == "8" ]; then
+    echo -e '\nPackaging for Debian...\n'
+    mkdir -p packages/debiantemp/sshyp_"$version"-"$revision"_all/{DEBIAN,usr/share/man/man1}
+    echo "Package: sshyp
+Version: $version
+Section: utils
+Architecture: all
+Maintainer: Randall Winkhart <idgr at tutanota dot com>
+Description: A light-weight, self-hosted, synchronized password manager
+Depends: python3, gnupg, openssh-client, xclip, wl-clipboard
+Priority: optional
+Installed-Size: 185
+" > packages/debiantemp/sshyp_"$version"-"$revision"_all/DEBIAN/control
+    cp -r bin packages/debiantemp/sshyp_"$version"-"$revision"_all/usr/
+    ln -s /usr/bin/sshyp.py packages/debiantemp/sshyp_"$version"-"$revision"_all/usr/bin/sshyp
+    cp -r share packages/debiantemp/sshyp_"$version"-"$revision"_all/usr/
+    cp extra/manpage packages/debiantemp/sshyp_"$version"-"$revision"_all/usr/share/man/man1/sshyp.1
+    gzip packages/debiantemp/sshyp_"$version"-"$revision"_all/usr/share/man/man1/sshyp.1
+    dpkg-deb --build --root-owner-group packages/debiantemp/sshyp_"$version"-"$revision"_all/
+    mv packages/debiantemp/sshyp_"$version"-"$revision"_all.deb packages/
+    rm -rf packages/debiantemp
+    echo -e "\nDebian packaging complete.\n"
+fi
+
+if [ "$distro" == "5" ] || [ "$distro" == "8" ]; then
+    echo -e '\nPackaging for Termux...\n'
+    mkdir -p packages/termuxtemp/sshyp_"$version"-"$revision"_all_termux/{data/data/com.termux/files/usr/share/man/man1,DEBIAN}
+    echo "Package: sshyp
+Version: $version
+Section: utils
+Architecture: all
+Maintainer: Randall Winkhart <idgr at tutanota dot com>
+Description: A light-weight, self-hosted, synchronized password manager
+Depends: python, gnupg, openssh, termux-api, termux-am
+Priority: optional
+Installed-Size: 185
+" > packages/termuxtemp/sshyp_"$version"-"$revision"_all_termux/DEBIAN/control
+    cp -r bin packages/termuxtemp/sshyp_"$version"-"$revision"_all_termux/data/data/com.termux/files/usr/
+    ln -s /data/data/com.termux/files/usr/bin/sshyp.py packages/termuxtemp/sshyp_"$version"-"$revision"_all_termux/data/data/com.termux/files/usr/bin/sshyp
+    cp -r share packages/termuxtemp/sshyp_"$version"-"$revision"_all_termux/data/data/com.termux/files/usr/
+    cp extra/manpage packages/termuxtemp/sshyp_"$version"-"$revision"_all_termux/data/data/com.termux/files/usr/share/man/man1/sshyp.1
+    gzip packages/termuxtemp/sshyp_"$version"-"$revision"_all_termux/data/data/com.termux/files/usr/share/man/man1/sshyp.1
+    dpkg-deb --build --root-owner-group packages/termuxtemp/sshyp_"$version"-"$revision"_all_termux/
+    mv packages/termuxtemp/sshyp_"$version"-"$revision"_all_termux.deb packages/
+    rm -rf packages/termuxtemp
+    echo -e "\nTermux packaging complete.\n"
+fi
+
+if [ "$distro" == "3" ] || [ "$distro" == "4" ] || [ "$distro" == "6" ] || [ "$distro" == "7" ] || [ "$distro" == "8" ]; then
+    echo -e '\nPackaging as generic...\n'
+    mkdir -p packages/generictemp/usr/share/man/man1
+    cp -r bin packages/generictemp/usr/
+    ln -s /usr/bin/sshyp.py packages/generictemp/usr/bin/sshyp
+    cp -r share packages/generictemp/usr/
+    cp extra/manpage packages/generictemp/usr/share/man/man1/sshyp.1
+    gzip packages/generictemp/usr/share/man/man1/sshyp.1
+    tar -C packages/generictemp -cvf packages/sshyp-"$version".tar.xz usr/
+    rm -rf packages/generictemp
+    sha512="$(sha512sum packages/sshyp-"$version".tar.xz | awk '{print $1;}')"
+    echo -e "\nsha512 sum:\n$sha512"
+    echo -e "\nGeneric packaging complete.\n"
+fi
+
+if [ "$distro" == "3" ]; then
+    echo -e '\nPackaging for Fedora...\n'
+    rm -rf ~/rpmbuild
+    rpmdev-setuptree
+    cp packages/sshyp-"$version".tar.xz ~/rpmbuild/SOURCES
+    echo "Name:           sshyp
+Version:        "$version"
+Release:        "$revision"
+Summary:        A light-weight, self-hosted, synchronized password manager
+BuildArch:      noarch
+
+License:        GPLv3
+URL:            https://github.com/rwinkhart/sshyp
+Source0:        sshyp-"$version".tar.xz
+
+Requires:       python gnupg openssh wl-clipboard
+
+%description
+sshyp is a password-store compatible CLI password manager available for UNIX(-like) systems - its primary goal is to make syncing passwords and notes across devices as easy as possible via CLI.
+
+%install
+tar xf %{_sourcedir}/sshyp-"$version".tar.xz -C %{_sourcedir}
+cp -r %{_sourcedir}/usr %{buildroot}
+
+%files
+/usr/bin/sshyp
+/usr/bin/sshyp.py
+/usr/bin/sshync.py
+/usr/bin/sshypRemote.py
+%license /usr/share/licenses/sshyp/license
+%doc /usr/share/doc/sshyp/changelog
+%doc /usr/share/man/man1/sshyp.1.gz
+" > ~/rpmbuild/SPECS/sshyp.spec
+rpmbuild -bb ~/rpmbuild/SPECS/sshyp.spec
+mv ~/rpmbuild/RPMS/noarch/* packages/
+rm -rf ~/rpmbuild
+echo -e "\nFedora packaging complete.\n"
+fi
+
+if [ "$distro" == "4" ] || [ "$distro" == "8" ]; then
+    echo -e '\nPackaging for FreeBSD...\n'
+    mkdir -p packages/FreeBSDtemp/bin
+    tar xf packages/sshyp-"$version".tar.xz -C packages/FreeBSDtemp
+    ln -s /usr/local/bin/python3 packages/FreeBSDtemp/bin/python3
+    echo "name: sshyp
+version: \""$version"\"
+abi = \"FreeBSD:13:*\";
+arch = \"freebsd:13:*\";
+origin: security/sshyp
+comment: \"a password manager\"
+desc: \"a light-weight, self-hosted, synchronized password manager\"
+maintainer: <idgr at tutanota dot com>
+www: https://github.com/rwinkhart/sshyp
+prefix: /
+\"deps\" : {
+                   \"python\" : {
+                      \"origin\" : \"lang/python\"
+                   },
+                   \"gnupg\" : {
+                      \"origin\" : \"security/gnupg\"
+                   },
+                   \"xclip\" : {
+                      \"origin\" : \"x11/xclip\"
+                   },
+                   \"wl-clipboard\" : {
+                      \"origin\" : \"x11/wl-clipboard\"
+                   },
+                },
+" > packages/FreeBSDtemp/+MANIFEST
+echo "/bin/python3
+/usr/bin/sshync.py
+/usr/bin/sshyp
+/usr/bin/sshyp.py
+/usr/bin/sshypRemote.py
+/usr/share/doc/sshyp/changelog
+/usr/share/licenses/sshyp/license
+/usr/share/man/man1/sshyp.1.gz
+" > packages/FreeBSDtemp/plist
+pkg create -m packages/FreeBSDtemp/ -r packages/FreeBSDtemp/ -p packages/FreeBSDtemp/plist -o packages/
+rm -rf packages/FreeBSDtemp
+echo -e "\nFreeBSD packaging complete.\n"
+fi
+
+if [ "$distro" == "7" ] || [ "$distro" == "8" ]; then
+    echo -e '\nGenerating PKGBUILD...'
+    echo "# Maintainer: Randall Winkhart <idgr at tutanota dot com>
+
+pkgname=sshyp
+pkgver="$version"
+pkgrel="$revision"
+pkgdesc='A light-weight, self-hosted, synchronized password manager'
+url='https://github.com/rwinkhart/sshyp'
+arch=('any')
+license=('GPL3')
+depends=(python gnupg openssh xclip wl-clipboard)
+
+source=(\""$source"\")
+sha512sums=('"$sha512"')
+
+package() {
+
+    tar xf sshyp-"\"\$pkgver\"".tar.xz -C "\"\${pkgdir}\""
+
+}
+" > packages/PKGBUILD
+    echo -e "\nPKGBUILD generated.\n"
+fi

share/doc/sshyp/changelog

@@ -0,0 +1,29 @@
+sshyp v1.1.1
+
+the sheecrets update - patch one
+
+this is a polish/bug fix release that makes tweaks to the entry format (without breaking compatibility)
+
+compatibility-breaking changes:
+
+- none; the entry format tweaks are backward compatible with sshyp v1.0.0+
+    ^ the new format is slightly more efficient in terms of storage space
+        ^ if you would like to upgrade to it, run this script (after updating to v1.1.1):
+          https://raw.githubusercontent.com/rwinkhart/sshyp-labs/main/extra/conversion-scripts/sshyp-refresh-1.1.1%2B.py
+
+user-facing features:
+
+- entries (when editing or adding) are now run through the new optimized_edit() function to strip trailing new lines
+and ensure the format of the entries is fully compatible with all of sshyp's functions
+
+fixes:
+
+- when adding a note to an entry, there is no longer a chance the first note line will be added as a url
+if the entry is using an older format/pass format
+- the gpg auto-generation file temporarily created by sshyp no longer includes extra spaces
+    ^ seems to serve no functional purpose - fixed for the sake of polish
+
+<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
+
+The full history of changes to "sshyp" can be found on the following page:
+https://raw.githubusercontent.com/rwinkhart/sshyp/main/extra/changelog-total

share/licenses/sshyp/license

@@ -1,5 +1,5 @@
-    rpass is a FOSS password manager that takes advantage of rsync
-    Copyright (C) 2021  Randall Winkhart  idgr@tutanota.com
+    sshyp is a FOSS password manager that uses an sftp-based syncing back-end.
+    Copyright (C) 2022  Randall Winkhart  idgr@tutanota.com
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by

usr/bin/rpass

@@ -1,605 +0,0 @@
-#!/usr/bin/python
-
-# rpass 2021.09.07.pr3.1
-# rpass is the gnu pass alternative for those who don't want to use git
-# rpass is freely licensed for modification and redistribution under the GNU General Public License V3
-
-from os import system
-from os import remove
-from os import environ
-from shutil import move
-from shutil import rmtree
-from sys import argv
-import random
-import string
-
-
-def clear():
-    print("\n" * 100)
-
-
-def term(cmd):
-    _ = system(cmd)
-
-
-def replace_line(file_name, line_num, text):
-    lines = open(file_name, 'r').readlines()
-    lines[line_num] = text
-    out = open(file_name, 'w')
-    out.writelines(lines)
-    out.close()
-
-
-def encrypt():
-    term('gpg -r ' + str(gpgid) + ' -e ' + "'" + '/dev/shm/' + shmfolder + '/' + shmentry + "'")
-    move('/dev/shm/' + shmfolder + '/' + shmentry + '.gpg', directory + entryname.replace('/', '', 1) + '.gpg')
-    rmtree('/dev/shm/' + shmfolder)
-
-
-def encryptfolder():
-    term('gpg -r ' + str(gpgid) + ' -e ' + "'" + '/dev/shm/' + shmfolder + '/' + shmentry + "'")
-    move('/dev/shm/' + shmfolder + '/' + shmentry + '.gpg', directory + folder + '/' + folderentry + '.gpg')
-    rmtree('/dev/shm/' + shmfolder)
-
-
-def rsyncup():
-    term(rsyncupp + ' ' + directory + ' ' + usernamessh + '@' + ip + ':' + directoryssh)
-
-
-def rsyncdown():
-    term(rsyncdownn + ' ' + usernamessh + '@' + ip + ':' + directoryssh + ' ' + directory)
-
-
-# argument - filter the argument to usable text - some replacements are only done once to prevent interference
-
-argument = str(argv).replace('[', '', 1).replace(']', '', 1).replace(',', '').replace("'", '') \
-    .replace(' ', '', 1).replace('/usr/bin/', '', 1).replace('rpass', '', 1)
-
-# startup help
-
-if argument == '':
-    clear()
-    print("use 'help', '--help', or '-h' to see a list of commands")
-    print()
-    print('<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>')
-    print("If you are receiving errors, run 'rpass config' and go through the guided setup wizard.")
-    print('This MUST be done before rpass will function!!')
-    print('<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>')
-    print()
-    print('rpass is currently early software with very little polish')
-    print()
-
-# help
-
-if argument == 'help' or argument == '--help' or argument == '-h':
-    print()
-    print('rpass  Copyright (C) 2021  Randall Winkhart')
-    print("This program comes with ABSOLUTELY NO WARRANTY; for details type `rpass show w'. This is free software, "
-          "and you are welcome to redistribute it under certain conditions; type `rpass show c' for details.")
-    print()
-    print('USAGE: rpass [/<entry name>] [OPTION] [FLAG]')
-    print()
-    print('Options: ')
-    print('help/--help/-h           bring up this menu')
-    print('config                   configure rpass')
-    print('add                      add an entry')
-    print('gen                      generate a new password')
-    print('edit                     edit an existing entry')
-    print('remove/-rm               delete an existing entry')
-    print('sync/-s                  manually sync the entry directory via rsync')
-    print()
-    print('Flags:')
-    print('add:')
-    print(' password/-p             add a password entry')
-    print(' note/-n                 add a note entry')
-    print(' folder/-f               add a new folder for entries')
-    print('edit:')
-    print(' rename/relocate/-r      rename or relocate an entry')
-    print(' username/-u             change the username of an entry')
-    print(' password/-p             change the password of an entry')
-    print(' note/-n                 change the note attached to an entry')
-    print(' url/-l                  change the url attached to an entry')
-    print('gen:')
-    print(' update/-u               generate a password for an existing entry')
-    print()
-    print("Tip: You can quickly read an entry with 'rpass /<entry name>'!")
-    print("When specifying entry names, do not include the file extension! '.gpg' is assumed!")
-    print()
-
-# licensing info
-
-if argument == 'show w':
-    clear()
-    print('This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;')
-    print('without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.')
-    print('See the GNU General Public License for more details.')
-    print()
-    print('https://opensource.org/licenses/GPL-3.0')
-    print()
-
-if argument == 'show c':
-    clear()
-    print('This program is free software: you can redistribute it and/or modify it under the terms of the GNU General')
-    print('Public License as published by the Free Software Foundation, either version 3 of the License,')
-    print('or (at your option) any later version.')
-    print()
-
-# config
-
-if argument == 'config':
-    print()
-    directorychoice = str(input('Would you like to use the default entry directory (~/.rpass-store/)? (Y/n) '))
-    if directorychoice != 'n':
-        with open("/var/lib/rpass/rpassdir", 'w') as f:
-            f.write('/home/' + environ.get('USER') + '/.rpass-store/' + '\n')
-    if directorychoice == 'n':
-        print()
-        print('Format: /this/path/ends/with/a/slash/')
-        print()
-        directory = str(input('Please input a custom directory: '))
-        with open("/var/lib/rpass/rpassdir", 'w') as f:
-            f.write(directory + '\n')
-    print()
-    gpgpresent = str(input('rpass requires the use of a unique gpg key. Do you already have one you are willing to '
-                           'use? (y/N) '))
-    if gpgpresent == 'y' or gpgpresent == 'Y':
-        print()
-        gpgid = str(input('Please input the ID of your gpg key: '))
-        with open("/var/lib/rpass/rpassgpg", 'w') as f:
-            f.write(gpgid + '\n')
-    if gpgpresent != 'y':
-        print()
-        gpggen = str(input('Would you like to generate one now? Note that if you choose not to do this, you will have '
-                           'to re-run "rpass config" to specify a gpg key when you acquire one (Y/n) '))
-        if gpggen != 'n':
-            term('gpg --full-generate-key')
-            print()
-            gpgid = str(input('Please input the ID of your gpg key: '))
-            with open("/var/lib/rpass/rpassgpg", 'w') as f:
-                f.write(gpgid + '\n')
-        if gpggen == 'n' or gpggen == 'N':
-            exit()
-    print()
-    syncsetup = str(input('Would you like to configure rsync over ssh for entry backup and syncing? (Y/n) '))
-    if syncsetup != 'n':
-        print()
-        sshgen = str(input('rsync support requires a unique ssh key. Would you like to have this '
-                           'automatically generated? (Y/n) '))
-        if sshgen != 'n':
-            term('ssh-keygen -f ~/.ssh/rpass')
-        print()
-        print('The server device(s) should be configured first.')
-        print()
-        devicetype = str(input('Will this be a client or a server device? (c/S) '))
-        if devicetype != 'c':
-            print()
-            print('Make sure the ssh service is running and that the proper port is forwarded.')
-        if devicetype == 'c':
-            print()
-            print('Make sure the ssh service is running and that the proper port is forwarded on the remote server.')
-            print('Example input: 10.10.10.10:9999')
-            print()
-            ip_port = str(input('What is the IP and ssh port of the remote server? '))
-            print()
-            usernamessh = str(input('What is the username of the remote server? '))
-            ip, sep, port = ip_port.partition(':')
-            with open("/var/lib/rpass/rpassuserssh", 'w') as f:
-                f.write(usernamessh + '\n')
-            with open("/var/lib/rpass/rpassrsyncup", 'w') as f:
-                f.write('rsync -v -H -r -l -t -p -e ' + '"ssh -i ~/.ssh/rpass -p ' + port + '" ' + '\n')
-            with open("/var/lib/rpass/rpassrsyncdown", 'w') as f:
-                f.write('rsync -v -H -r -l -t -p --delete -e ' + '"ssh -i ~/.ssh/rpass -p ' + port + '" ' + '\n')
-            with open("/var/lib/rpass/rpassip", 'w') as f:
-                f.write(ip + '\n')
-            print()
-            print('Default directory: ' + '/home/' + usernamessh + '/.rpass-store/')
-            print()
-            directoryssh = str(input('Is the remote server using the default password directory? (Y/n) '))
-            if directoryssh != 'n':
-                directoryssh = ('/home/' + usernamessh + '/.rpass-store/')
-            if directoryssh == 'n' or directoryssh == 'N':
-                print()
-                print('Format: /this/path/ends/with/a/slash/')
-                print()
-                directoryssh = str(input('What directory is the server using?: '))
-            with open("/var/lib/rpass/rpassdirssh", 'w') as f:
-                f.write(directoryssh + '\n')
-
-# import userdata
-
-with open("/var/lib/rpass/rpassgpg") as f:
-    gpgid = f.read().strip()
-with open("/var/lib/rpass/rpassdir") as f:
-    directory = f.read().strip()
-term('mkdir -p ' + directory)
-with open("/var/lib/rpass/rpassdirssh") as f:
-    directoryssh = f.read().strip()
-with open("/var/lib/rpass/rpassrsyncup") as f:
-    rsyncupp = f.read().strip()
-with open("/var/lib/rpass/rpassrsyncdown") as f:
-    rsyncdownn = f.read().strip()
-with open("/var/lib/rpass/rpassip") as f:
-    ip = f.read().strip()
-with open("/var/lib/rpass/rpassuserssh") as f:
-    usernamessh = f.read().strip()
-
-if argument == '':
-    print()
-    term('cd ~/.rpass-store; ls -1 *')
-    print()
-    readentry = str(input('Entry to read: '))
-    clear()
-    term('gpg -d ' + directory + "'" + readentry.replace('/', '', 1) + "'" + '.gpg')
-    print()
-
-# read shortcut
-
-if argument.startswith('/'):
-    if argument.replace('/', '', 1).__contains__('/'):
-        folder, sep, folderentry = argument.replace('/', '', 1).partition('/')
-        term('gpg -d ' + directory + folder + '/' + "'" + folderentry + '.gpg' + "'")
-    else:
-        term('gpg -d ' + directory + "'" + argument.replace('/', '', 1) + '.gpg' + "'")
-
-# add
-
-if argument == 'add':
-    print()
-    print('USAGE: rpass add [FLAG]')
-    print('Flags:')
-    print('add:')
-    print(' password/-p             add a password entry')
-    print(' note/-n                 add a note entry')
-    print(' folder/-f               add a new folder for entries')
-    print()
-
-if argument == 'add note' or argument == 'add -n':
-    clear()
-    entryname = str(input('Name of note: '))
-    notes = str(input('Contents of note: '))
-    # generate random strings for /dev/shm
-    shmfolder = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                        for _ in range(random.randint(10, 30)))
-    shmentry = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                       for _ in range(random.randint(10, 30)))
-    term('mkdir -p /dev/shm/' + shmfolder)
-    # end string and folder generation
-    if entryname.startswith('/'):
-        if entryname.replace('/', '', 1).__contains__('/'):
-            folder, sep, folderentry = entryname.replace('/', '', 1).partition('/')
-            with open('/dev/shm/' + shmfolder + '/' + shmentry, 'w') as f:
-                f.writelines('\n\n\n' + notes + '\n\n')
-            encryptfolder()
-            term('gpg -d ' + directory + folder + '/' + "'" + folderentry + '.gpg' + "'")
-        else:
-            with open('/dev/shm/' + shmfolder + '/' + shmentry, 'w') as f:
-                f.writelines('\n\n\n' + notes + '\n\n')
-            encrypt()
-            term('gpg -d ' + directory + "'" + entryname.replace('/', '', 1) + '.gpg' + "'")
-    else:
-        with open('/dev/shm/' + shmfolder + '/' + shmentry, 'w') as f:
-            f.writelines('\n\n\n' + notes + '\n\n')
-        encrypt()
-        term('gpg -d ' + directory + "'" + entryname + '.gpg' + "'")
-
-if argument == 'add password' or argument == 'add -p':
-    clear()
-    entryname = str(input('Name of service: '))
-    username = str(input('Username: '))
-    password = str(input('Password: '))
-    url = str(input('URL: '))
-    notes = str(input('Additional notes: '))
-    # generate random strings for /dev/shm
-    shmfolder = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                        for _ in range(random.randint(10, 30)))
-    shmentry = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                       for _ in range(random.randint(10, 30)))
-    term('mkdir -p /dev/shm/' + shmfolder)
-    # end string and folder generation
-    if entryname.startswith('/'):
-        if entryname.replace('/', '', 1).__contains__('/'):
-            folder, sep, folderentry = entryname.replace('/', '', 1).partition('/')
-            with open('/dev/shm/' + shmfolder + '/' + shmentry, 'w') as f:
-                f.writelines(username + '\n' + password + '\n' + url + '\n' + notes + '\n\n')
-            encryptfolder()
-            term('gpg -d ' + directory + folder + '/' + "'" + folderentry + '.gpg' + "'")
-        else:
-            with open('/dev/shm/' + shmfolder + '/' + shmentry, 'w') as f:
-                f.writelines(username + '\n' + password + '\n' + url + '\n' + notes + '\n\n')
-            encrypt()
-            term('gpg -d ' + directory + "'" + entryname.replace('/', '', 1) + '.gpg' + "'")
-    else:
-        with open('/dev/shm/' + shmfolder + '/' + shmentry, 'w') as f:
-            f.writelines(username + '\n' + password + '\n' + url + '\n' + notes + '\n\n')
-        encrypt()
-        term('gpg -d ' + directory + "'" + entryname + '.gpg' + "'")
-
-if argument == 'add folder' or argument == 'add -f':
-    newfolder = str(input('Name of new folder: '))
-    term('mkdir ' + "'" + directory + newfolder + "'")
-
-# edit
-
-if argument == 'edit':
-    print()
-    print('USAGE: rpass edit [FLAG]')
-    print('Flags:')
-    print('edit:')
-    print(' rename/relocate/-r      rename or relocate an entry')
-    print(' username/-u             change the username of an entry')
-    print(' password/-p             change the password of an entry')
-    print(' note/-n                 change the note attached to an entry')
-    print(' url/-l                  change the url attached to an entry')
-    print()
-
-if argument == 'edit rename' or argument == 'edit relocate' or argument == 'edit -r':
-    clear()
-    term('cd ~/.rpass-store; ls -1 *')
-    print()
-    entryname = str(input('What file would you like to edit? '))
-    newname = str(input('New Name: '))
-    if entryname.startswith('/'):
-        if entryname.replace('/', '', 1).__contains__('/'):
-            folder, sep, folderentry = entryname.replace('/', '', 1).partition('/')
-            move(directory + folder + '/' + folderentry + '.gpg', directory + '/' + newname + '.gpg')
-        else:
-            move(directory + entryname.replace('/', '', 1) + '.gpg', directory + newname.replace('/', '', 1) + '.gpg')
-    else:
-        move(directory + entryname + '.gpg', directory + newname + '.gpg')
-
-if argument == 'edit username' or argument == 'edit -u':
-    clear()
-    term('cd ~/.rpass-store; ls -1 *')
-    print()
-    entryname = str(input('What file would you like to edit? '))
-    username = str(input('New Username: '))
-    # generate random strings for /dev/shm
-    shmfolder = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                        for _ in range(random.randint(10, 30)))
-    shmentry = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                       for _ in range(random.randint(10, 30)))
-    term('mkdir -p /dev/shm/' + shmfolder)
-    # end string and folder generation
-    if entryname.startswith('/'):
-        if entryname.replace('/', '', 1).__contains__('/'):
-            folder, sep, folderentry = entryname.replace('/', '', 1).partition('/')
-            term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory +
-                 folder + '/' + folderentry + '.gpg')
-            replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 0, username + '\n')
-            remove(directory + folder + '/' + folderentry + '.gpg')
-            encryptfolder()
-            term('gpg -d ' + directory + folder + '/' + "'" + folderentry + '.gpg' + "'")
-        else:
-            term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory +
-                 entryname.replace('/', '', 1) + '.gpg')
-            replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 0, username + '\n')
-            remove(directory + entryname.replace('/', '', 1) + '.gpg')
-            encrypt()
-            term('gpg -d ' + directory + "'" + entryname.replace('/', '', 1) + '.gpg' + "'")
-    else:
-        term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory + entryname + '.gpg')
-        replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 0, username + '\n')
-        remove(directory + entryname + '.gpg')
-        encrypt()
-        term('gpg -d ' + directory + "'" + entryname + '.gpg' + "'")
-
-if argument == 'edit password' or argument == 'edit -p':
-    clear()
-    term('cd ~/.rpass-store; ls -1 *')
-    print()
-    entryname = str(input('What file would you like to edit? '))
-    password = str(input('New Password: '))
-    # generate random strings for /dev/shm
-    shmfolder = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                        for _ in range(random.randint(10, 30)))
-    shmentry = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                       for _ in range(random.randint(10, 30)))
-    term('mkdir -p /dev/shm/' + shmfolder)
-    # end string and folder generation
-    if entryname.startswith('/'):
-        if entryname.replace('/', '', 1).__contains__('/'):
-            folder, sep, folderentry = entryname.replace('/', '', 1).partition('/')
-            term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory +
-                 folder + '/' + folderentry + '.gpg')
-            replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 1, password + '\n')
-            remove(directory + folder + '/' + folderentry + '.gpg')
-            encryptfolder()
-            term('gpg -d ' + directory + folder + '/' + "'" + folderentry + '.gpg' + "'")
-        else:
-            term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory +
-                 entryname.replace('/', '', 1) + '.gpg')
-            replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 1, password + '\n')
-            remove(directory + entryname.replace('/', '', 1) + '.gpg')
-            encrypt()
-            term('gpg -d ' + directory + "'" + entryname.replace('/', '', 1) + '.gpg' + "'")
-    else:
-        term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory + entryname + '.gpg')
-        replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 1, password + '\n')
-        remove(directory + entryname + '.gpg')
-        encrypt()
-        term('gpg -d ' + directory + "'" + entryname + '.gpg' + "'")
-
-if argument == 'edit url' or argument == 'edit -l':
-    clear()
-    term('cd ~/.rpass-store; ls -1 *')
-    print()
-    entryname = str(input('What file would you like to edit? '))
-    url = str(input('New URL: '))
-    # generate random strings for /dev/shm
-    shmfolder = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                        for _ in range(random.randint(10, 30)))
-    shmentry = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                       for _ in range(random.randint(10, 30)))
-    term('mkdir -p /dev/shm/' + shmfolder)
-    # end string and folder generation
-    if entryname.startswith('/'):
-        if entryname.replace('/', '', 1).__contains__('/'):
-            folder, sep, folderentry = entryname.replace('/', '', 1).partition('/')
-            term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory +
-                 folder + '/' + folderentry + '.gpg')
-            replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 2, url + '\n')
-            remove(directory + folder + '/' + folderentry + '.gpg')
-            encryptfolder()
-            term('gpg -d ' + directory + folder + '/' + "'" + folderentry + '.gpg' + "'")
-        else:
-            term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory +
-                 entryname.replace('/', '', 1) + '.gpg')
-            replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 2, url + '\n')
-            remove(directory + entryname.replace('/', '', 1) + '.gpg')
-            encrypt()
-            term('gpg -d ' + directory + "'" + entryname.replace('/', '', 1) + '.gpg' + "'")
-    else:
-        term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory + entryname + '.gpg')
-        replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 2, url + '\n')
-        remove(directory + entryname + '.gpg')
-        encrypt()
-        term('gpg -d ' + directory + "'" + entryname + '.gpg' + "'")
-
-if argument == 'edit note' or argument == 'edit -n':
-    clear()
-    term('cd ~/.rpass-store; ls -1 *')
-    print()
-    entryname = str(input('What file would you like to edit? '))
-    notes = str(input('New Note: '))
-    # generate random strings for /dev/shm
-    shmfolder = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                        for _ in range(random.randint(10, 30)))
-    shmentry = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                       for _ in range(random.randint(10, 30)))
-    term('mkdir -p /dev/shm/' + shmfolder)
-    # end string and folder generation
-    if entryname.startswith('/'):
-        if entryname.replace('/', '', 1).__contains__('/'):
-            folder, sep, folderentry = entryname.replace('/', '', 1).partition('/')
-            term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory +
-                 folder + '/' + folderentry + '.gpg')
-            replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 3, notes + '\n')
-            remove(directory + folder + '/' + folderentry + '.gpg')
-            encryptfolder()
-            term('gpg -d ' + directory + folder + '/' + "'" + folderentry + '.gpg' + "'")
-        else:
-            term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory +
-                 entryname.replace('/', '', 1) + '.gpg')
-            replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 3, notes + '\n')
-            remove(directory + entryname.replace('/', '', 1) + '.gpg')
-            encrypt()
-            term('gpg -d ' + directory + "'" + entryname.replace('/', '', 1) + '.gpg' + "'")
-    else:
-        term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory + entryname + '.gpg')
-        replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 3, notes + '\n')
-        remove(directory + entryname + '.gpg')
-        encrypt()
-        term('gpg -d ' + directory + "'" + entryname + '.gpg' + "'")
-
-# gen
-
-if argument == 'gen':
-    clear()
-    entryname = str(input('Name of service: '))
-    username = str(input('Username: '))
-    passlength = int(input('How many characters should be in the password? '))
-    passtype = str(input('Should the password be simple (for compatibility) or complex (for security)? (s/C) '))
-    if passtype != 's':
-        passtype = string.ascii_letters + string.digits + string.punctuation
-    if passtype == 's':
-        passtype = string.ascii_letters + string.digits
-    passgen = ''.join(random.SystemRandom().choice(passtype) for _ in range(passlength))
-    url = str(input('URL: '))
-    notes = str(input('Additional notes: '))
-    # generate random strings for /dev/shm
-    shmfolder = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                        for _ in range(random.randint(10, 30)))
-    shmentry = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                       for _ in range(random.randint(10, 30)))
-    term('mkdir -p /dev/shm/' + shmfolder)
-    # end string and folder generation
-    if entryname.startswith('/'):
-        if entryname.replace('/', '', 1).__contains__('/'):
-            folder, sep, folderentry = entryname.replace('/', '', 1).partition('/')
-            with open('/dev/shm/' + shmfolder + '/' + shmentry, 'w') as f:
-                f.writelines(username + '\n' + passgen + '\n' + url + '\n' + notes + '\n\n')
-            encryptfolder()
-            term('gpg -d ' + directory + folder + '/' + "'" + folderentry + '.gpg' + "'")
-        else:
-            with open('/dev/shm/' + shmfolder + '/' + shmentry, 'w') as f:
-                f.writelines(username + '\n' + passgen + '\n' + url + '\n' + notes + '\n\n')
-            encrypt()
-            term('gpg -d ' + directory + "'" + entryname.replace('/', '', 1) + '.gpg' + "'")
-    else:
-        with open('/dev/shm/' + shmfolder + '/' + shmentry, 'w') as f:
-            f.writelines(username + '\n' + passgen + '\n' + url + '\n' + notes + '\n\n')
-        encrypt()
-        term('gpg -d ' + directory + "'" + entryname + '.gpg' + "'")
-
-if argument == 'gen update' or argument == 'gen -u':
-    clear()
-    term('cd ~/.rpass-store; ls -1 *')
-    print()
-    entryname = str(input('Which password would you like to re-generate? '))
-    passlength = int(input('How many characters should be in the password? '))
-    passtype = str(input('Should the password be simple (for compatibility) or complex (for security)? (s/C) '))
-    # generate random strings for /dev/shm
-    shmfolder = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                        for _ in range(random.randint(10, 30)))
-    shmentry = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits)
-                       for _ in range(random.randint(10, 30)))
-    term('mkdir -p /dev/shm/' + shmfolder)
-    # end string and folder generation
-    if passtype != 's':
-        passtype = string.ascii_letters + string.digits + string.punctuation
-    if passtype == 's':
-        passtype = string.ascii_letters + string.digits
-    passgen = ''.join(random.SystemRandom().choice(passtype) for _ in range(passlength))
-    if entryname.startswith('/'):
-        if entryname.replace('/', '', 1).__contains__('/'):
-            folder, sep, folderentry = entryname.replace('/', '', 1).partition('/')
-            term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory +
-                 folder + '/' + folderentry + '.gpg')
-            replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 1, passgen + '\n')
-            remove(directory + folder + '/' + folderentry.replace('/', '', 1) + '.gpg')
-            encryptfolder()
-            term('gpg -d ' + directory + folder + '/' + "'" + folderentry + '.gpg' + "'")
-        else:
-            term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory +
-                 entryname.replace('/', '', 1) + '.gpg')
-            replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 1, passgen + '\n')
-            remove(directory + entryname.replace('/', '', 1) + '.gpg')
-            encrypt()
-            term('gpg -d ' + directory + "'" + entryname.replace('/', '', 1) + '.gpg' + "'")
-    else:
-        term('gpg --output /dev/shm/' + shmfolder + '/' + shmentry + ' ' + directory + entryname + '.gpg')
-        replace_line('/dev/shm/' + shmfolder + '/' + shmentry, 1, passgen + '\n')
-        remove(directory + entryname + '.gpg')
-        encrypt()
-        term('gpg -d ' + directory + "'" + entryname + '.gpg' + "'")
-
-# remove
-
-if argument == 'remove' or argument == '-rm':
-    clear()
-    term('cd ~/.rpass-store; ls -1 *')
-    print()
-    entryname = str(input('What would you like to delete? '))
-    if entryname.startswith('/'):
-        if entryname.replace('/', '', 1).__contains__('/'):
-            remove(directory + entryname.replace('/', '', 1) + '.gpg')
-        else:
-            rmtree(directory + entryname.replace('/', '', 1))
-    else:
-        remove(directory + entryname + '.gpg')
-
-# permissions - applied pre-sync to ensure permissions are correct before upload
-
-term('find ' + directory + ' -type d -exec chmod -R 700 {} +')
-term('find ' + directory + ' -type f -exec chmod -R 600 {} +')
-
-# rsync - ran at end of program to ensure all files are properly synced
-
-if argument.__contains__('add') or argument.__contains__('-rm') or argument.__contains__('remove') or argument. \
-        __contains__('edit') or argument.__contains__('gen') or argument == 'sync' or argument == '-s':
-    rsyncup()
-    rsyncdown()
-    print()
-    print('Please note that as of this time, entries can only be deleted if removed from the central server in a '
-          'client-server scenario. This will be adjusted soon.')
-    print()

usr/share/doc/rpass/changelog

@@ -1,165 +0,0 @@
-<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
-
-rpass-2021.09.08.pr4
-
-The Housekeeping Update - Fourth public release of rpass
-
-This release focuses primarily on polishing rpass and tying up loose ends before
-making any major changes in the future.
-
-New features:
-
-**overhaul error message using exceptions
-**add exceptions for unknown arguments
-**make clean, colorful file list by exporting to document and removing extensions
-**make a manpage
-**multi-line notes?
-
-Changes:
-
-**move project to github
-**change gpg prompt to get rid of expiration date
-**get rid of gpg decryption warnings
-**optimize code (specifically for when there is no folder but there is a slash)
-**add version info argument
-**update rsync config wizard
-**properly comment the code
-**validate for Python 3.10
-
-Planned for next update (The Secret Update):
-
-- allow to function as alternative to gnome keyring (libsecret integration)
-
-Planned, no timeline:
-
-- create separate gui frontend targetting mobile devices (first linux phones, maybe android at a later date - official iOS client not likely)
-    ^ the gui will also function on desktop linux
-- make platform agnostic (add windows support and package for more Linux distributions)
-- ability to pass entries as arguments for more functions
-- auto-completion on tab (currently unsure of best way to make this work)
-
-<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
-
-rpass 2021.09.07.pr3.1
-
-The Sync and Foundations Update - Hotfix
-
-Changes:
-
-- gpg configuration now prompts for expiration, rather than defaulting to two years
-- rsync is now configured to not delete anything from any remote device when uploading
-    ^ this behavior may be modified in the future - this is a quick fix to prevent data loss
-
-<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
-
-rpass 2021.09.07.pr3
-
-The Sync and Foundations Update - Third public release of rpass.
-
-As of this version, rpass has its intended base set of features and is considered usable.
-It will now primarily recieve bug fixes and polish updates to prepare it to go
-cross-platform and to make it compatible with GUI frontends.
-
-New features:
-
-- rsync support!
-- new entry format with URL field (for future use)
-- the temporary directory (/dev/shm) for editing entries has been somewhat secured
-
-Changes:
-
-- 'rpass edit relocate' is now properly bound
-- dropped the use of 'echo'
-- added 'rsync' and 'openssh' as dependencies
-- fixed a bug with deleting entries from folders
-- entry directory now has more secure permissions
-        ^ these permissions are re-enforced every time rpass is used
-- fixed some small typos and potential bugs, made some small optimizations
-
-Planned for next update (The Housekeeping Update):
-
-- move to github
-- get rid of gpg decryption warnings
-- proper error messages using 'except'
-- add exceptions for unknown arguments
-- cleanup file list by exporting to document and removing .gpg, adding color
-- add a manpage
-- allow notes to be multiple lines long (break lines after so many characters)
-- validate for Python 3.10
-- properly comment the code
-
-Planned, no timeline:
-
-- allow to function as alternative to gnome keyring (libsecret integration)
-- create separate gui frontend targetting mobile devices (first linux phones, maybe android at a later date - official iOS client not likely)
-    ^ the gui will also function on desktop linux
-- make platform agnostic (add windows support and package for more Linux distributions)
-- ability to pass entries as arguments for more functions
-- auto-completion on tab (currently unsure of best way to make this work)
-
-<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
-
-rpass 2021.09.02.pr2
-
-The Folder Update - Second public release of rpass.
-
-New features:
-
-- entry and folder titles can now have spaces and be as long as you want
-- entires and folders can now be deleted with 'rpass remove' or 'rpass -rm'
-- entries now properly save to folders via 'rpass add' and should no longer throw errors
-- entries saved in folders are now readable
-- existing entries can now be moved to, from, and between folders
-- previews are now shown after creating or editing an entry
-
-Changes:
-
-- every pre-existing function of rpass has been updated to work with the new folder system
-- dropped awk as a dependency
-- removed 'argument' file in /var/lib/rpass
-- reduced unneccessary characters in argument parsing to decrease compatibility issues
-- ensured all user input is handled correctly as a string or an integer
-- lots of miscellaneous optimizations
-
-Expected for next update (The rsync Update):
-
-- rsync (over ssh) support!
-    ^ including any fixes, changes, or optimizations necessary to make that happen
-- new file formatting with support for URLs
-    ^all entries created in new format should be compatible with future versions of rpass
-- secure /dev/shm with random text generator
-
-Expected for the next (next) update (The Housekeeping Update)
-
-- get rid of gpg decryption warnings
-- proper error messages using 'except'
-- add exceptions for unknown arguments
-- cleanup file list by exporting to document and removing .gpg, adding color
-
-Planned, no timeline:
-
-- make platform agnostic (basically, add windows support)
-- create separate gui frontend targetting mobile devices (first linux phones, android at a later date)
-    ^ the gui will also function on desktop linux
-- ability to pass entries as arguments for more functions
-- auto-completion on tab
-
-<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
-
-rpass 2021.09.01.pr1.1
-
-First public release of rpass.
-
-Early build, missing critical features (e.g. sync support and the ability to have spaces in filenames).
-
-What is currently functional:
-
-- guided configuration wizard
-- generate passwords
-- add existing passwords
-- make notes
-- sort notes and passwords into folders
-- gpg encryption
-- edit password/note entries
-
-<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>