sudo apt update
sudo apt install gnupg openssl bash python3-full mktemp vim fzf tree

sudo dnf install gnupg openssl bash python3 mktemp vim fzf tree

brew install gnupg openssl python@3.11 fzf tree

gpg --full-generate-key

mkdir -p ~/SecureNotes
cd ~/SecureNotes

echo "My top secret shopping list:
- Milk
- Eggs
- Quantum Computer Parts (for home project)
" > secret_shopping.txt

gpg --encrypt --recipient "john.doe@example.com" secret_shopping.txt

ls -l

rm secret_shopping.txt

gpg --decrypt secret_shopping.txt.gpg

gpg --output decrypted_shopping.txt --decrypt secret_shopping.txt.gpg

cat decrypted_shopping.txt

echo "Another secret: Don't tell anyone I like pineapple on pizza." > pizza_secret.txt

openssl enc -aes-256-cbc -salt -in pizza_secret.txt -out pizza_secret.txt.enc

ls -l pizza_secret.*

rm pizza_secret.txt

openssl enc -aes-256-cbc -d -in pizza_secret.txt.enc -out pizza_secret_decrypted.txt

cat pizza_secret_decrypted.txt

rm pizza_secret_decrypted.txt

mkdir -p ~/SecureNotes
tree -a ~/SecureNotes # This command might not show anything yet if you just created it.

#!/bin/bash

# Configuration
NOTES_DIR="$HOME/SecureNotes"
GPG_RECIPIENT="john.doe@example.com" # !!! IMPORTANT: Change this to your GPG email !!!
EDITOR="${EDITOR:-vim}" # Use system default editor or vim

# Ensure the notes directory exists
mkdir -p "$NOTES_DIR"

# Prompt for a descriptive title
read -p "Enter note title: " NOTE_TITLE

if [ -z "$NOTE_TITLE" ]; then
    echo "Note title cannot be empty. Aborting."
    exit 1
fi

# Sanitize title for filename
FILENAME_TITLE=$(echo "$NOTE_TITLE" | tr -c 'a-zA-Z0-9_' '-' | sed 's/-\{1,\}/-/g' | sed 's/^-//;s/-$//' | tr '[:upper:]' '[:lower:]')

# Create a unique temporary file
TEMP_FILE=$(mktemp)
if [ $? -ne 0 ]; then
    echo "Error creating temporary file. Aborting."
    exit 1
fi

# Ensure the temporary file is deleted on exit, even if script fails
trap "rm -f \"$TEMP_FILE\"" EXIT

echo "Opening editor for '$NOTE_TITLE'..."
"$EDITOR" "$TEMP_FILE"

# Check if content was added (file size > 0)
if [ ! -s "$TEMP_FILE" ]; then
    echo "Note is empty. Not saving."
    exit 0
fi

# Generate a timestamp for the filename
TIMESTAMP=$(date +%Y%m%d%H%M%S)

# Construct the final encrypted filename
ENCRYPTED_FILE="${NOTES_DIR}/${TIMESTAMP}-${FILENAME_TITLE}.gpg"

echo "Encrypting and saving note to '$ENCRYPTED_FILE'..."
gpg --encrypt --recipient "$GPG_RECIPIENT" --output "$ENCRYPTED_FILE" "$TEMP_FILE"

if [ $? -eq 0 ]; then
    echo "Note saved successfully."
else
    echo "Error encrypting note. Original content is still in '$TEMP_FILE' (will be deleted on exit)."
    exit 1
fi

# The trap will handle deleting TEMP_FILE

chmod +x ~/bin/note-new

~/bin/note-new

ls -l ~/SecureNotes/

#!/bin/bash

# Configuration
NOTES_DIR="$HOME/SecureNotes"
GPG_RECIPIENT="john.doe@example.com" # !!! IMPORTANT: Change this to your GPG email !!!
EDITOR="${EDITOR:-vim}" # Use system default editor or vim

# Ensure the notes directory exists
if [ ! -d "$NOTES_DIR" ]; then
    echo "Notes directory not found: $NOTES_DIR"
    echo "Create some notes first using 'note-new'."
    exit 1
fi

# List .gpg files, allow selection with fzf if available, otherwise prompt.
# Only show the base filename for clarity.
NOTES=$(find "$NOTES_DIR" -type f -name "*.gpg" -printf "%f\n" | sort -r)

if [ -z "$NOTES" ]; then
    echo "No encrypted notes found in $NOTES_DIR. Create one using 'note-new'."
    exit 0
fi

SELECTED_NOTE_BASENAME=""
if command -v fzf &>/dev/null; then
    # Use fzf for interactive selection
    SELECTED_NOTE_BASENAME=$(echo "$NOTES" | fzf --prompt="Select note to view: ")
else
    # Fallback to simple numbered list if fzf is not available
    echo "Available notes:"
    SELECTABLE_NOTES=()
    i=1
    while IFS= read -r note; do
        echo "  $i) $note"
        SELECTABLE_NOTES+=("$note")
        i=$((i+1))
    done <<< "$NOTES"

    if [ ${#SELECTABLE_NOTES[@]} -eq 0 ]; then
        echo "No notes found."
        exit 0
    fi

    read -p "Enter number to view: " selection_num
    if [[ "$selection_num" =~ ^[0-9]+$ ]] && [ "$selection_num" -ge 1 ] && [ "$selection_num" -le ${#SELECTABLE_NOTES[@]} ]; then
        SELECTED_NOTE_BASENAME="${SELECTABLE_NOTES[$((selection_num-1))]}"
    else
        echo "Invalid selection. Aborting."
        exit 1
    fi
fi

if [ -z "$SELECTED_NOTE_BASENAME" ]; then
    echo "No note selected. Exiting."
    exit 0
fi

ENCRYPTED_FILE="${NOTES_DIR}/${SELECTED_NOTE_BASENAME}"

# Create a unique temporary file for decryption
TEMP_FILE=$(mktemp)
if [ $? -ne 0 ]; then
    echo "Error creating temporary file. Aborting."
    exit 1
fi

# Ensure the temporary file is deleted on exit
trap "rm -f \"$TEMP_FILE\"" EXIT

echo "Decrypting '$SELECTED_NOTE_BASENAME'..."
# Decrypt the note to the temporary file
gpg --decrypt --output "$TEMP_FILE" "$ENCRYPTED_FILE"
if [ $? -ne 0 ]; then
    echo "Error decrypting note. Check your GPG passphrase."
    exit 1
fi

# Get the initial modification time of the decrypted file
# This helps us determine if the file was modified by the editor
INITIAL_MTIME=$(stat -c %Y "$TEMP_FILE" 2>/dev/null || stat -f %m "$TEMP_FILE" 2>/dev/null)

echo "Opening editor for '$SELECTED_NOTE_BASENAME'..."
"$EDITOR" "$TEMP_FILE"

# Get the final modification time
FINAL_MTIME=$(stat -c %Y "$TEMP_FILE" 2>/dev/null || stat -f %m "$TEMP_FILE" 2>/dev/null)

# Check if the file was modified
if [ "$INITIAL_MTIME" != "$FINAL_MTIME" ]; then
    echo "Note modified. Re-encrypting..."
    gpg --encrypt --recipient "$GPG_RECIPIENT" --output "$ENCRYPTED_FILE" "$TEMP_FILE"
    if [ $? -eq 0 ]; then
        echo "Note re-encrypted successfully."
    else
        echo "Error re-encrypting note. Original encrypted file untouched."
        exit 1
    fi
else
    echo "Note not modified. No re-encryption needed."
fi

# The trap will handle deleting TEMP_FILE

chmod +x ~/bin/note-view

~/bin/note-view

#!/bin/bash

# Configuration
NOTES_DIR="$HOME/SecureNotes"
SEARCH_TERM="$1" # The first argument will be our search term

# Ensure search term is provided
if [ -z "$SEARCH_TERM" ]; then
    echo "Usage: note-search <search_term>"
    exit 1
fi

# Create a temporary directory for decrypted notes
TEMP_DIR=$(mktemp -d)
if [ $? -ne 0 ]; then
    echo "Error creating temporary directory. Aborting."
    exit 1
fi

# Ensure the temporary directory is deleted on exit
trap "rm -rf \"$TEMP_DIR\"" EXIT

echo "Decrypting notes to temporary directory for search..."

# Decrypt all .gpg notes into the temporary directory
for ENCRYPTED_FILE in "$NOTES_DIR"/*.gpg; do
    if [ -f "$ENCRYPTED_FILE" ]; then
        BASENAME=$(basename "$ENCRYPTED_FILE" .gpg)
        DECRYPTED_FILE="$TEMP_DIR/$BASENAME"
        gpg --decrypt --output "$DECRYPTED_FILE" "$ENCRYPTED_FILE" &>/dev/null # Suppress GPG output
        if [ $? -ne 0 ]; then
            echo "Warning: Failed to decrypt $ENCRYPTED_FILE. Skipping."
            rm -f "$DECRYPTED_FILE" # Clean up partial decryption
        fi
    fi
done

echo "Searching for '$SEARCH_TERM'..."

# Search within the decrypted notes
grep -i -n "$SEARCH_TERM" "$TEMP_DIR"/* 2>/dev/null | sed "s|$TEMP_DIR/||"

if [ $? -ne 0 ]; then
    echo "No matches found."
fi

echo "Search complete. Temporary files cleaned up."
# The trap will handle deleting TEMP_DIR

chmod +x ~/bin/note-search

~/bin/note-search "shopping list"

#!/usr/bin/env python3

import os
import sys
import subprocess
import tempfile
import shutil
from datetime import datetime

# --- Configuration ---
NOTES_DIR = os.path.expanduser("~/SecureNotes")
GPG_RECIPIENT = "john.doe@example.com" # !!! IMPORTANT: Change this to your GPG email !!!
EDITOR = os.environ.get("EDITOR", "vim")

# Ensure the notes directory exists
os.makedirs(NOTES_DIR, exist_ok=True)

def run_command(cmd, input_data=None, suppress_output=False):
    """Helper to run shell commands."""
    try:
        process = subprocess.run(
            cmd,
            input=input_data,
            capture_output=suppress_output,
            text=True,
            check=True
        )
        if suppress_output:
            return process.stdout.strip()
        else:
            return process.returncode == 0
    except subprocess.CalledProcessError as e:
        print(f"Error running command: {' '.join(cmd)}", file=sys.stderr)
        print(f"Stderr: {e.stderr}", file=sys.stderr)
        print(f"Stdout: {e.stdout}", file=sys.stderr)
        return False
    except FileNotFoundError:
        print(f"Error: Command not found. Is '{cmd[0]}' installed and in your PATH?", file=sys.stderr)
        return False

def new_note():
    """Create a new encrypted note."""
    title = input("Enter note title: ").strip()
    if not title:
        print("Note title cannot be empty. Aborting.")
        return

    # Sanitize title for filename
    filename_title = "".join(c if c.isalnum() else "-" for c in title).lower()
    filename_title = "-".join(filter(None, filename_title.split('-'))) # Remove multiple hyphens and leading/trailing
    if not filename_title: # Fallback if title becomes empty after sanitization
        filename_title = "untitled"

    timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
    encrypted_filepath = os.path.join(NOTES_DIR, f"{timestamp}-{filename_title}.gpg")

    with tempfile.NamedTemporaryFile(mode='w+', delete=False, encoding='utf-8') as tmp_file:
        tmp_path = tmp_file.name

    try:
        print(f"Opening editor for '{title}'...")
        # Open editor
        cmd = [EDITOR, tmp_path]
        editor_process = subprocess.run(cmd)

        if editor_process.returncode != 0:
            print("Editor exited with an error. Aborting note creation.", file=sys.stderr)
            return

        # Check if content was added
        if os.path.getsize(tmp_path) == 0:
            print("Note is empty. Not saving.")
            return

        print(f"Encrypting and saving note to '{encrypted_filepath}'...")
        gpg_cmd = [
            "gpg", "--encrypt", "--recipient", GPG_RECIPIENT,
            "--output", encrypted_filepath, tmp_path
        ]
        if run_command(gpg_cmd):
            print("Note saved successfully.")
        else:
            print("Failed to encrypt note. Check GPG setup.", file=sys.stderr)

    finally:
        # Clean up the temporary file
        if os.path.exists(tmp_path):
            os.remove(tmp_path)

def list_notes():
    """List all encrypted notes."""
    notes = sorted([f for f in os.listdir(NOTES_DIR) if f.endswith(".gpg")], reverse=True)
    if not notes:
        print("No notes found. Create one using 'notes new'.")
        return []

    print("Available notes:")
    for i, note in enumerate(notes):
        print(f"  {i+1}) {note}")
    return notes

def view_note():
    """View/edit an existing encrypted note."""
    notes = list_notes()
    if not notes:
        return

    selection = input("Enter number or part of filename to view: ").strip()

    selected_note_basename = None
    if selection.isdigit():
        idx = int(selection) - 1
        if 0 <= idx < len(notes):
            selected_note_basename = notes[idx]
    else: # Try fuzzy match
        matching_notes = [n for n in notes if selection.lower() in n.lower()]
        if len(matching_notes) == 1:
            selected_note_basename = matching_notes[0]
        elif len(matching_notes) > 1:
            print("Multiple matches found. Please be more specific or use the number:")
            for note in matching_notes:
                print(f"  - {note}")
            return
        else:
            print(f"No note found matching '{selection}'.")
            return

    if not selected_note_basename:
        print("Invalid selection.")
        return

    encrypted_filepath = os.path.join(NOTES_DIR, selected_note_basename)

    with tempfile.NamedTemporaryFile(mode='w+', delete=False, encoding='utf-8') as tmp_file:
        tmp_path = tmp_file.name

    try:
        print(f"Decrypting '{selected_note_basename}'...")
        gpg_decrypt_cmd = ["gpg", "--decrypt", "--output", tmp_path, encrypted_filepath]
        if not run_command(gpg_decrypt_cmd):
            print("Failed to decrypt note. Check your GPG passphrase.", file=sys.stderr)
            return

        initial_mtime = os.path.getmtime(tmp_path)

        print(f"Opening editor for '{selected_note_basename}'...")
        editor_process = subprocess.run([EDITOR, tmp_path])

        if editor_process.returncode != 0:
            print("Editor exited with an error. Changes might not be saved.", file=sys.stderr)
            return

        final_mtime = os.path.getmtime(tmp_path)

        if final_mtime > initial_mtime:
            print("Note modified. Re-encrypting...")
            gpg_encrypt_cmd = [
                "gpg", "--encrypt", "--recipient", GPG_RECIPIENT,
                "--output", encrypted_filepath, tmp_path
            ]
            if run_command(gpg_encrypt_cmd):
                print("Note re-encrypted successfully.")
            else:
                print("Failed to re-encrypt note. Original encrypted file is unchanged.", file=sys.stderr)
        else:
            print("Note not modified. No re-encryption needed.")

    finally:
        if os.path.exists(tmp_path):
            os.remove(tmp_path)

def search_notes():
    """Search content across all encrypted notes."""
    search_term = input("Enter search term: ").strip()
    if not search_term:
        print("Search term cannot be empty.")
        return

    temp_search_dir = tempfile.mkdtemp()
    try:
        print("Decrypting notes for search (this may take a moment)...")
        decrypted_files = []
        for encrypted_file in os.listdir(NOTES_DIR):
            if encrypted_file.endswith(".gpg"):
                full_encrypted_path = os.path.join(NOTES_DIR, encrypted_file)
                base_name = os.path.splitext(encrypted_file)[0]
                decrypted_path = os.path.join(temp_search_dir, base_name)

                # Decrypt silently for search
                gpg_decrypt_cmd = ["gpg", "--decrypt", "--output", decrypted_path, full_encrypted_path]
                if not run_command(gpg_decrypt_cmd, suppress_output=True):
                    print(f"Warning: Failed to decrypt '{encrypted_file}'. Skipping.", file=sys.stderr)
                    if os.path.exists(decrypted_path):
                        os.remove(decrypted_path) # Clean up partial decrypt
                    continue
                decrypted_files.append(decrypted_path)

        if not decrypted_files:
            print("No decryptable notes found to search.")
            return

        print(f"\nSearching for '{search_term}'...")
        grep_cmd = ["grep", "-i", "-n", search_term] + decrypted_files
        try:
            grep_output = subprocess.run(grep_cmd, capture_output=True, text=True, check=True)
            for line in grep_output.stdout.splitlines():
                # Replace temp dir path with actual filename for cleaner output
                clean_line = line.replace(temp_search_dir + os.sep, "")
                print(clean_line)
            print("Search complete.")
        except subprocess.CalledProcessError:
            print("No matches found.")

    finally:
        # Clean up the temporary directory and its contents
        if os.path.exists(temp_search_dir):
            shutil.rmtree(temp_search_dir)

def display_help():
    print("Usage: notes <command>")
    print("\nCommands:")
    print("  new      - Create a new encrypted note.")
    print("  list     - List all existing encrypted notes.")
    print("  view     - View and optionally edit an existing encrypted note.")
    print("  search   - Search content within all encrypted notes.")
    print("  help     - Display this help message.")
    print("\nConfiguration:")
    print(f"  Notes directory: {NOTES_DIR}")
    print(f"  GPG Recipient:   {GPG_RECIPIENT}")
    print(f"  Editor:          {EDITOR}")


if __name__ == "__main__":
    if len(sys.argv) < 2:
        display_help()
        sys.exit(1)

    command = sys.argv[1].lower()

    if command == "new":
        new_note()
    elif command == "list":
        list_notes()
    elif command == "view":
        view_note()
    elif command == "search":
        search_notes()
    elif command == "help":
        display_help()
    else:
        print(f"Unknown command: '{command}'", file=sys.stderr)
        display_help()
        sys.exit(1)

chmod +x ~/bin/notes.py

notes.py new

notes.py list

notes.py view

notes.py search "quantum"