Move packages out of src/

backend/1globals.go

@@ -0,0 +1,17 @@
+package backend
+
+import (
+	"os"
+)
+
+// global variables used across multiple files
+var (
+	Home, _ = os.UserHomeDir()
+)
+
+// global constants used across multiple files
+const (
+	AnsiError        = "\033[38;5;9m"
+	AnsiReset        = "\033[0m"
+	LibmuttonVersion = "0.2.0" // untagged releases feature a letter suffix corresponding to the eventual release version, e.g "0.2.A" -> "0.2.0", "0.2.B" -> "0.2.1"
+)

backend/2globalsUNIX.go

@@ -0,0 +1,20 @@
+//go:build !windows
+
+package backend
+
+// EntryRoot path to libmutton entry directory
+var EntryRoot = Home + "/.local/share/libmutton"
+var ConfigDir = Home + "/.config/libmutton"
+var ConfigPath = ConfigDir + "/libmutton.ini"
+
+// PathSeparator defines the character used to separate directories in a path (platform-specific)
+const (
+	PathSeparator = "/"
+	IsWindows     = false
+)
+
+// enableVirtualTerminalProcessing is a dummy function on UNIX-like systems (only needed on Windows)
+// TODO remove after migration off of GPG, as pinentry is responsible for disabling ANSI escape sequence interpretation
+func enableVirtualTerminalProcessing() {
+	return
+}

backend/2globalsWIN.go

@@ -0,0 +1,31 @@
+//go:build windows
+
+package backend
+
+import (
+	"os"
+	"syscall"
+)
+
+// EntryRoot path to libmutton entry directory
+var EntryRoot = Home + "\\AppData\\Local\\libmutton\\entries"
+var ConfigDir = Home + "\\AppData\\Local\\libmutton\\config"
+var ConfigPath = ConfigDir + "\\libmutton.ini"
+
+// PathSeparator defines the character used to separate directories in a path (platform-specific)
+const (
+	PathSeparator = "\\"
+	IsWindows     = true
+)
+
+// enableVirtualTerminalProcessing ensures ANSI escape sequences are interpreted properly on Windows
+// TODO remove after migration off of GPG, as pinentry is responsible for disabling ANSI escape sequence interpretation
+func enableVirtualTerminalProcessing() {
+	stdout := syscall.Handle(os.Stdout.Fd())
+
+	var originalMode uint32
+	syscall.GetConsoleMode(stdout, &originalMode)
+	originalMode |= 0x0004
+
+	syscall.MustLoadDLL("kernel32").MustFindProc("SetConsoleMode").Call(uintptr(stdout), uintptr(originalMode))
+}

backend/configParser.go

@@ -0,0 +1,86 @@
+package backend
+
+import (
+	"fmt"
+	"os"
+
+	"gopkg.in/ini.v1"
+)
+
+// loadConfig loads the libmutton.ini file and returns the configuration
+// utility function for ParseConfig and WriteConfig, do not call directly
+func loadConfig() *ini.File {
+	cfg, err := ini.Load(ConfigPath)
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to load libmutton.ini: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+	return cfg
+}
+
+// ParseConfig reads the libmutton.ini file and returns a slice of values for the specified keys
+// requires requestedValues: a slice of arrays (length 2) each containing a section and a key name
+// requires missingValueError: an error message to display if a key is missing a value, set to "" for auto-generated or "0" to exit/return silently with code 0
+// returns config: a slice of values for the specified keys
+func ParseConfig(valuesRequested [][2]string, missingValueError string) []string {
+	cfg := loadConfig()
+
+	var config []string
+
+	for _, pair := range valuesRequested {
+		value := cfg.Section(pair[0]).Key(pair[1]).String()
+
+		// ensure specified key has a value
+		if value == "" {
+			switch missingValueError {
+			case "":
+				fmt.Println(AnsiError + "Failed to find value for key \"" + pair[1] + "\" in section \"[" + pair[0] + "]\" in libmutton.ini" + AnsiReset)
+			case "0":
+				Exit(0)
+			default:
+				fmt.Println(AnsiError + missingValueError + AnsiReset)
+			}
+			os.Exit(1)
+		}
+
+		config = append(config, value)
+	}
+
+	return config
+}
+
+// WriteConfig writes the provided key-value pairs under the specified section headers in the libmutton.ini file
+// requires valuesToWrite: a slice of arrays (length 3) each containing a section, a key name, and a value
+func WriteConfig(valuesToWrite [][3]string, append bool) {
+	var cfg *ini.File
+
+	if append {
+		// load existing ini file
+		cfg = loadConfig()
+	} else {
+		// create empty ini container
+		cfg = ini.Empty()
+	}
+
+	// set all specified key-value pairs in their respective sections
+	var section *ini.Section
+	for _, trio := range valuesToWrite {
+		if cfg.Section(trio[0]) == nil {
+			// create and aquire section if it doesn't exist
+			section, _ = cfg.NewSection(trio[0])
+		} else {
+			// acquire existing section
+			section = cfg.Section(trio[0])
+		}
+
+		// set key-value pair
+		section.Key(trio[1]).SetValue(trio[2])
+	}
+
+	// save to libmutton.ini
+	err := cfg.SaveTo(ConfigPath)
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to save libmutton.ini: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+}

backend/copy.go

@@ -0,0 +1,91 @@
+package backend
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	steamtotp "github.com/fortis/go-steam-totp"
+	"github.com/pquerna/otp/totp"
+)
+
+// CopyArgument copies a field from an entry to the clipboard
+func CopyArgument(executableName, targetLocation string, field int) {
+	if isFile, _ := TargetIsFile(targetLocation, true, 2); isFile {
+
+		decryptedEntry := DecryptGPG(targetLocation)
+		var copySubject string // will store data to be copied
+
+		// ensure field exists in entry
+		if len(decryptedEntry) > field {
+
+			// ensure field is not empty
+			if decryptedEntry[field] == "" {
+				fmt.Println(AnsiError + "Field is empty" + AnsiReset)
+				os.Exit(1)
+			}
+
+			if field != 2 {
+				copySubject = decryptedEntry[field]
+			} else { // TOTP mode
+				var secret string // stores secret for TOTP generation
+				var forSteam bool // indicates whether to generate TOTP in Steam format
+
+				if strings.HasPrefix(decryptedEntry[2], "steam@") {
+					secret = decryptedEntry[2][6:]
+					forSteam = true
+				} else {
+					secret = decryptedEntry[2]
+				}
+
+				fmt.Println("TOTP code has been copied to the clipboard - your clipboard will be kept up to date with the current code until this process is closed")
+
+				for { // keep field copied to clipboard, refresh on 30-second intervals
+					currentTime := time.Now()
+					copyField("", GenTOTP(secret, currentTime, forSteam))
+					// sleep until next 30-second interval
+					time.Sleep(time.Duration(30-(currentTime.Second()%30)) * time.Second)
+				}
+			}
+		} else {
+			fmt.Println(AnsiError + "Field does not exist in entry" + AnsiReset)
+			os.Exit(1)
+		}
+
+		// copy field to clipboard, launch clipboard clearing process
+		copyField(executableName, copySubject)
+	}
+}
+
+// ClipClearArgument is called to clear the clipboard after 30 seconds if the contents have not been modified
+func ClipClearArgument() {
+	// read previous clipboard contents from stdin
+	clipScanner := bufio.NewScanner(os.Stdin)
+	if clipScanner.Scan() {
+		oldContents := clipScanner.Text()
+		clipClear(oldContents)
+	} else {
+		os.Exit(0) // use os.Exit instead of backend.Exit, as this function runs out of a background subprocess that is invisible to the user (will never appear in GUI/TUI environment)
+	}
+}
+
+// GenTOTP generates a TOTP token from a secret (supports standard and Steam TOTP)
+func GenTOTP(secret string, time time.Time, forSteam bool) string {
+	var totpToken string
+	var err error
+
+	if forSteam {
+		totpToken, err = steamtotp.GenerateAuthCode(secret, time)
+	} else {
+		totpToken, err = totp.GenerateCode(secret, time)
+	}
+
+	if err != nil {
+		fmt.Println(AnsiError + "Error generating TOTP code" + AnsiReset)
+		os.Exit(1)
+	}
+
+	return totpToken
+}

backend/copyDARWIN.go

@@ -0,0 +1,59 @@
+//go:build darwin
+
+package backend
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+// TODO MacOS support is entirely untested - I would appreciate feedback on this implementation
+
+// copyField copies a field from an entry to the clipboard
+func copyField(executableName, copySubject string) {
+	cmd := exec.Command("pbcopy")
+	writeToStdin(cmd, copySubject)
+	err := cmd.Run()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to copy to clipboard: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	// launch clipboard clearing process if executableName is provided
+	if executableName != "" {
+		cmd = exec.Command(executableName, "clipclear")
+		writeToStdin(cmd, copySubject)
+		err = cmd.Start()
+		if err != nil {
+			fmt.Println(AnsiError + "Failed to launch automated clipboard clearing process - does this libmutton implementation support the \"clipclear\" argument?" + AnsiReset)
+			os.Exit(1)
+		}
+		Exit(0) // only exit if clipboard clearing process is launched, otherwise assume continuous clipboard refresh
+	}
+}
+
+// clipClear is called in a separate process to clear the clipboard after 30 seconds
+func clipClear(oldContents string) {
+	time.Sleep(30 * time.Second)
+
+	cmd := exec.Command("pbpaste")
+	newContents, err := cmd.Output()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to read clipboard contents: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	if oldContents == strings.TrimRight(string(newContents), "\r\n") {
+		cmd = exec.Command("pbcopy")
+		writeToStdin(cmd, "")
+		err = cmd.Run()
+		if err != nil {
+			fmt.Println(AnsiError + "Failed to clear clipboard: " + err.Error() + AnsiReset)
+			os.Exit(1)
+		}
+	}
+	os.Exit(0) // use os.Exit instead of backend.Exit, as this function runs out of a background subprocess that is invisible to the user (will never appear in GUI/TUI environment)
+}

backend/copyTERMUX.go

@@ -0,0 +1,57 @@
+//go:build linux && termux
+
+package backend
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+// copyField copies a field from an entry to the clipboard
+func copyField(executableName, copySubject string) {
+	cmd := exec.Command("termux-clipboard-set")
+	writeToStdin(cmd, copySubject)
+	err := cmd.Run()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to copy to clipboard: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	// launch clipboard clearing process if executableName is provided
+	if executableName != "" {
+		cmd = exec.Command(executableName, "clipclear")
+		writeToStdin(cmd, copySubject)
+		err = cmd.Start()
+		if err != nil {
+			fmt.Println(AnsiError + "Failed to launch automated clipboard clearing process - does this libmutton implementation support the \"clipclear\" argument?" + AnsiReset)
+			os.Exit(1)
+		}
+		Exit(0) // only exit if clipboard clearing process is launched, otherwise assume continuous clipboard refresh
+	}
+}
+
+// clipClear is called in a separate process to clear the clipboard after 30 seconds
+func clipClear(oldContents string) {
+	time.Sleep(30 * time.Second)
+
+	cmd := exec.Command("termux-clipboard-get")
+	newContents, err := cmd.Output()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to read clipboard contents: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	if oldContents == strings.TrimRight(string(newContents), "\r\n") {
+		cmd = exec.Command("termux-clipboard-set")
+		writeToStdin(cmd, "")
+		err = cmd.Run()
+		if err != nil {
+			fmt.Println(AnsiError + "Failed to clear clipboard: " + err.Error() + AnsiReset)
+			os.Exit(1)
+		}
+	}
+	os.Exit(0) // use os.Exit instead of backend.Exit, as this function runs out of a background subprocess that is invisible to the user (will never appear in GUI/TUI environment)
+}

backend/copyUNIXGeneric.go

@@ -0,0 +1,81 @@
+//go:build !windows && !darwin && !termux && !wsl
+
+package backend
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+// copyField copies a field from an entry to the clipboard
+func copyField(executableName, copySubject string) {
+	var envSet bool // track whether environment variables are set
+	var cmd *exec.Cmd
+	// determine whether to use wl-copy (Wayland) or xclip (X11)
+	if _, envSet = os.LookupEnv("WAYLAND_DISPLAY"); envSet {
+		cmd = exec.Command("wl-copy")
+	} else if _, envSet = os.LookupEnv("DISPLAY"); envSet {
+		cmd = exec.Command("xclip", "-sel", "c")
+	} else {
+		fmt.Println(AnsiError + "Clipboard platform could not be determined - note that the clipboard does not function in a raw TTY" + AnsiReset)
+		os.Exit(1)
+	}
+
+	writeToStdin(cmd, copySubject)
+	err := cmd.Run()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to copy to clipboard: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	// launch clipboard clearing process if executableName is provided
+	if executableName != "" {
+		cmd = exec.Command(executableName, "clipclear")
+		writeToStdin(cmd, copySubject)
+		err = cmd.Start()
+		if err != nil {
+			fmt.Println(AnsiError + "Failed to launch automated clipboard clearing process - does this libmutton implementation support the \"clipclear\" argument?" + AnsiReset)
+			os.Exit(1)
+		}
+		Exit(0) // only exit if clipboard clearing process is launched, otherwise assume continuous clipboard refresh
+	}
+}
+
+// clipClear is called in a separate process to clear the clipboard after 30 seconds
+func clipClear(oldContents string) {
+	time.Sleep(30 * time.Second)
+
+	// determine clipboard tool to use (wl-clipboard VS xclip)
+	var envSet bool
+	var cmdClear, cmdPaste *exec.Cmd
+	if _, envSet = os.LookupEnv("WAYLAND_DISPLAY"); envSet {
+		cmdClear = exec.Command("wl-copy", "-c")
+		cmdPaste = exec.Command("wl-paste")
+	} else if _, envSet = os.LookupEnv("DISPLAY"); envSet {
+		cmdClear = exec.Command("xclip", "-i", "/dev/null", "-sel", "c")
+		cmdPaste = exec.Command("xclip", "-o", "-sel", "c")
+	} else {
+		fmt.Println(AnsiError + "Clipboard platform could not be determined - neither $WAYLAND_DISPLAY nor $DISPLAY are set" + AnsiReset)
+		os.Exit(1)
+	}
+
+	// read current clipboard contents
+	newContents, err := cmdPaste.Output()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to read clipboard contents: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	// clear clipboard if contents have not been modified
+	if oldContents == strings.TrimRight(string(newContents), "\r\n") {
+		err = cmdClear.Run()
+		if err != nil {
+			fmt.Println(AnsiError + "Failed to clear clipboard: " + err.Error() + AnsiReset)
+			os.Exit(1)
+		}
+	}
+	os.Exit(0) // use os.Exit instead of backend.Exit, as this function runs out of a background subprocess that is invisible to the user (will never appear in GUI/TUI environment)
+}

backend/copyWIN.go

@@ -0,0 +1,55 @@
+//go:build windows || (linux && wsl)
+
+package backend
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+// copyField copies a field from an entry to the clipboard
+func copyField(executableName, copySubject string) {
+	cmd := exec.Command("powershell.exe", "-c", fmt.Sprintf("echo '%s' | Set-Clipboard", strings.ReplaceAll(copySubject, "'", "''")))
+	err := cmd.Run()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to copy to clipboard: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	// launch clipboard clearing process if executableName is provided
+	if executableName != "" {
+		cmd = exec.Command(executableName, "clipclear")
+		writeToStdin(cmd, copySubject)
+		err = cmd.Start()
+		if err != nil {
+			fmt.Println(AnsiError + "Failed to launch automated clipboard clearing process - does this libmutton implementation support the \"clipclear\" argument?" + AnsiReset)
+			os.Exit(1)
+		}
+		Exit(0) // only exit if clipboard clearing process is launched, otherwise assume continuous clipboard refresh
+	}
+}
+
+// clipClear is called in a separate process to clear the clipboard after 30 seconds
+func clipClear(oldContents string) {
+	time.Sleep(30 * time.Second)
+
+	cmd := exec.Command("powershell.exe", "-c", "Get-Clipboard")
+	newContents, err := cmd.Output()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to read clipboard contents: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	if oldContents == strings.TrimRight(string(newContents), "\r\n") {
+		cmd = exec.Command("powershell.exe", "-c", "Set-Clipboard")
+		err = cmd.Run()
+		if err != nil {
+			fmt.Println(AnsiError + "Failed to clear clipboard: " + err.Error() + AnsiReset)
+			os.Exit(1)
+		}
+	}
+	os.Exit(0) // use os.Exit instead of backend.Exit, as this function runs out of a background subprocess that is invisible to the user (will never appear in GUI/TUI environment)
+}

backend/edit.go

@@ -0,0 +1,25 @@
+package backend
+
+// GetOldEntryData decrypts and returns old entry data (with all required lines present)
+func GetOldEntryData(targetLocation string, field int) []string {
+	// ensure targetLocation exists
+	TargetIsFile(targetLocation, true, 2)
+
+	// read old entry data
+	unencryptedEntry := DecryptGPG(targetLocation)
+
+	// return the old entry data with all required lines present
+	if field > 0 {
+		return EnsureSliceLength(unencryptedEntry, field)
+	} else {
+		return unencryptedEntry
+	}
+}
+
+// EnsureSliceLength ensures slice is long enough to contain the specified index
+func EnsureSliceLength(slice []string, index int) []string {
+	for len(slice) <= index {
+		slice = append(slice, "")
+	}
+	return slice
+}

backend/exitHard.go

@@ -0,0 +1,9 @@
+//go:build !returnOnExit
+
+package backend
+
+import "os"
+
+func Exit(code int) {
+	os.Exit(code)
+}

backend/exitSoft.go

@@ -0,0 +1,7 @@
+//go:build returnOnExit
+
+package backend
+
+func Exit(code int) {
+	return code
+}

backend/gpg.go

@@ -0,0 +1,39 @@
+package backend
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+// TODO GPG support is a temporary feature - it will be replaced with a different encryption scheme in the future
+
+// DecryptGPG decrypts a GPG-encrypted file and returns the contents as a slice of (trimmed) strings
+func DecryptGPG(targetLocation string) []string {
+	cmd := exec.Command("gpg", "--pinentry-mode", "loopback", "-q", "-d", targetLocation)
+	output, err := cmd.Output()
+
+	// ensure ANSI escape sequences are interpreted properly on Windows
+	enableVirtualTerminalProcessing()
+
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to decrypt \"" + targetLocation + "\" - ensure it is a valid GPG-encrypted file and that you entered your passphrase correctly" + AnsiReset)
+		os.Exit(1)
+	}
+	outputSlice := strings.Split(string(output), "\n")
+
+	return outputSlice
+}
+
+// EncryptGPG encrypts a slice of strings using GPG and returns the encrypted data as a byte slice
+func EncryptGPG(input []string) []byte {
+	cmd := exec.Command("gpg", "-q", "-r", ParseConfig([][2]string{{"LIBMUTTON", "gpgID"}}, "")[0], "-e")
+	writeToStdin(cmd, strings.Join(input, "\n"))
+	encryptedBytes, err := cmd.Output()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to encrypt data - ensure that your GPG key is valid and that you have a valid GPG ID set in libmutton.ini" + AnsiReset)
+		os.Exit(1)
+	}
+	return encryptedBytes
+}

backend/init.go

@@ -0,0 +1,82 @@
+package backend
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// GpgUIDListGen generates a list of all GPG key IDs on the system and returns them as a slice of strings
+func GpgUIDListGen() []string {
+	cmd := exec.Command("gpg", "-k", "--with-colons")
+	gpgOutputBytes, _ := cmd.Output()
+	gpgOutputLines := strings.Split(string(gpgOutputBytes), "\n")
+	var uidSlice []string
+	for _, line := range gpgOutputLines {
+		if strings.HasPrefix(line, "uid") {
+			uid := strings.Split(line, ":")[9]
+			uidSlice = append(uidSlice, uid)
+		}
+	}
+	return uidSlice
+}
+
+// GpgKeyGen generates a new GPG key and returns the key ID
+func GpgKeyGen() string {
+	gpgGenTempFile := CreateTempFile()
+	defer func(name string) {
+		_ = os.Remove(name) // error ignored; if the file could be created, it can probably be removed
+	}(gpgGenTempFile.Name())
+
+	// create and write gpg-gen file
+	unixTime := strconv.FormatInt(time.Now().Unix(), 10)
+	_, _ = gpgGenTempFile.WriteString(strings.Join([]string{"Key-Type: eddsa", "Key-Curve: ed25519", "Key-Usage: sign", "Subkey-Type: ecdh", "Subkey-Curve: cv25519", "Subkey-Usage: encrypt", "Name-Real: libmutton-" + unixTime, "Name-Comment: gpg-libmutton", "Name-Email: github.com/rwinkhart/libmutton", "Expire-Date: 0"}, "\n")) // error ignored; if the file could be created, it can probably be written to
+
+	// close gpg-gen file
+	_ = gpgGenTempFile.Close() // error ignored; if the file could be created, it can probably be closed
+
+	// generate GPG key based on gpg-gen file
+	cmd := exec.Command("gpg", "-q", "--batch", "--generate-key", gpgGenTempFile.Name())
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Stdin = os.Stdin
+	err := cmd.Run()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to generate GPG key: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	return "libmutton-" + unixTime + " (gpg-libmutton) <github.com/rwinkhart/libmutton>"
+}
+
+// DirInit creates the libmutton directories
+func DirInit(preserveOldConfigDir bool) {
+	// create EntryRoot
+	err := os.MkdirAll(EntryRoot, 0700)
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to create \"" + EntryRoot + "\":" + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	// remove existing config directory (if it exists and not in append mode)
+	if !preserveOldConfigDir {
+		_, isAccessible := TargetIsFile(ConfigDir, false, 1)
+		if isAccessible {
+			err = os.RemoveAll(ConfigDir)
+			if err != nil {
+				fmt.Println(AnsiError + "Failed to remove existing config directory: " + err.Error() + AnsiReset)
+				os.Exit(1)
+			}
+		}
+	}
+
+	// create config directory w/devices subdirectory
+	err = os.MkdirAll(ConfigDir+PathSeparator+"devices", 0700)
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to create \"" + ConfigDir + "\":" + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+}

backend/targetLocationFormatUNIX.go

@@ -0,0 +1,8 @@
+//go:build !windows
+
+package backend
+
+// TargetLocationFormat returns the full location of an entry (given the name) formatted for the current platform
+func TargetLocationFormat(targetLocationIncomplete string) string {
+	return EntryRoot + targetLocationIncomplete
+}

backend/targetLocationFormatWIN.go

@@ -0,0 +1,10 @@
+//go:build windows
+
+package backend
+
+import "strings"
+
+// TargetLocationFormat returns the full location of an entry (given the name) formatted for the current platform
+func TargetLocationFormat(targetLocationIncomplete string) string {
+	return EntryRoot + strings.ReplaceAll(targetLocationIncomplete, "/", PathSeparator)
+}

backend/utilitiesMisc.go

@@ -0,0 +1,157 @@
+package backend
+
+import (
+	"crypto/rand"
+	"fmt"
+	"io"
+	"math"
+	"math/big"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+// TargetIsFile TargetStatusCheck checks if the targetLocation is a file, directory, or is inaccessible
+// failCondition: 0 = fail on inaccessible, 1 = fail on inaccessible/file, 2 = fail on inaccessible/directory
+// returns: isFile, isAccessible
+func TargetIsFile(targetLocation string, errorOnFail bool, failCondition uint8) (bool, bool) {
+	targetInfo, err := os.Stat(targetLocation)
+	if err != nil {
+		if errorOnFail {
+			fmt.Println(AnsiError + "Failed to access \"" + targetLocation + "\" - ensure it exists and has the correct permissions" + AnsiReset)
+			os.Exit(1)
+		} else {
+			return false, false
+		}
+	}
+	if targetInfo.IsDir() {
+		if errorOnFail && failCondition == 2 {
+			fmt.Println(AnsiError + "\"" + targetLocation + "\" is a directory" + AnsiReset)
+			os.Exit(1)
+		}
+		return false, true
+	} else {
+		if errorOnFail && failCondition == 1 {
+			fmt.Println(AnsiError + "\"" + targetLocation + "\" is a file" + AnsiReset)
+			os.Exit(1)
+		}
+		return true, true
+	}
+}
+
+// WriteEntry writes entryData to an encrypted file at targetLocation
+func WriteEntry(targetLocation string, entryData []string, verifyEntryDoesNotExist bool) {
+	if verifyEntryDoesNotExist {
+		_, isAccessible := TargetIsFile(targetLocation, false, 0)
+		if isAccessible {
+			fmt.Println(AnsiError + "Target location already exists" + AnsiReset)
+			os.Exit(1)
+		}
+	}
+
+	encryptedBytes := EncryptGPG(entryData)
+	err := os.WriteFile(targetLocation, encryptedBytes, 0600)
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to write to file: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+}
+
+// writeToStdin writes a string to a command's stdin
+func writeToStdin(cmd *exec.Cmd, input string) {
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to access stdin for system command: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+
+	go func() {
+		defer func(stdin io.WriteCloser) {
+			_ = stdin.Close() // error ignored; if stdin could be accessed, it can probably be closed
+		}(stdin)
+		_, _ = io.WriteString(stdin, input)
+	}()
+}
+
+// CreateTempFile creates a temporary file and returns a pointer to it
+func CreateTempFile() *os.File {
+	tempFile, err := os.CreateTemp("", "*.markdown")
+	if err != nil {
+		fmt.Println(AnsiError + "Failed to create temporary file: " + err.Error() + AnsiReset)
+		os.Exit(1)
+	}
+	return tempFile
+}
+
+// RemoveTrailingEmptyStrings removes empty strings from the end of a slice
+func RemoveTrailingEmptyStrings(slice []string) []string {
+	for i := len(slice) - 1; i >= 0; i-- {
+		if slice[i] != "" {
+			return slice[:i+1]
+		}
+	}
+	return []string{}
+}
+
+// StringGen generates a random string of a specified length and complexity
+// safeForFileName: if true, the generated string will only contain special characters that are safe for file names (only impacts complex strings)
+// complexity: minimum percentage of special characters to be returned in the generated string (only impacts complex strings)
+func StringGen(length int, complex bool, complexity float64, safeForFileName bool) string {
+	var actualSpecialChars int // track the number of special characters in the generated string
+	var minSpecialChars int    // track the minimum number of special characters to accept
+	var extendedCharset string // additions to character set used for complex strings
+
+	charset := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" // default character set used for all strings
+	const extendedCharsetFiles = "!#$%&'()+,-.;=@[]^_`{}~"                      // additional special characters for complex strings (safe in file names)
+	const extendedCharsetPassword = "\"*:><?/\\|"                               // additional special characters for complex strings (NOT safe in file names)
+	if complex {
+		minSpecialChars = int(math.Round(float64(length) * complexity)) // determine minimum number of special characters to accept
+		if !safeForFileName {
+			extendedCharset = extendedCharsetFiles + extendedCharsetPassword
+		} else {
+			extendedCharset = extendedCharsetFiles
+		}
+		charset += extendedCharset
+	}
+
+	// loop until a string of the desired complexity is generated
+	for {
+		// generate a random string
+		result := make([]byte, length)
+		for i := range result {
+			val, _ := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
+			result[i] = charset[val.Int64()]
+		}
+
+		// return early if the string is not complex
+		if !complex {
+			return string(result)
+		}
+
+		// count the number of special characters in the generated string
+		for _, char := range string(result) {
+			if strings.ContainsRune(extendedCharset, char) {
+				actualSpecialChars++
+			}
+		}
+
+		// return the generated string if it contains enough special characters
+		if actualSpecialChars >= minSpecialChars {
+			return string(result)
+		}
+
+		// reset special character counter
+		fmt.Println("Regenerating string until desired complexity is achieved...")
+		actualSpecialChars = 0
+	}
+}
+
+// EntryIsNotEmpty iterates through entryData and returns true if any line is not empty
+func EntryIsNotEmpty(entryData []string) bool {
+	for _, line := range entryData {
+		if line != "" {
+			return true
+		}
+	}
+	return false
+}