Generate an SSH Key on Any OS

You only need one solid SSH key pair to unlock remote SQLite hosts from SQLitePilot. The steps below walk through the most common environments so you can generate a modern Ed25519 key (or fall back to RSA if required).

Before you start

• Pick a short, memorable label for the key so you recognize it later (for example work-laptop-main).
• Decide where the private key should live. The default ~/.ssh folder is correct for Linux, macOS, WSL, and Git Bash. On Windows PowerShell, the equivalent folder is %UserProfile%\.ssh (usually C:\Users\<you>\.ssh).
• Close any clipboard or password manager apps that might auto-format text, because private keys must keep their original spacing when you copy them into SQLitePilot.

Linux or macOS (Terminal + OpenSSH)

1. Open Terminal.
2. Run mkdir -p ~/.ssh && chmod 700 ~/.ssh to make sure the directory exists with safe permissions.
3. Generate the key:

ssh-keygen -t ed25519 -a 100 -f ~/.ssh/id_ed25519 -C "work-laptop-main"

• Use -t rsa -b 4096 only if your system rejects ed25519.
• The -a 100 flag adds key-derivation rounds for better brute-force resistance.

4. Press Enter to accept the default path (unless you need a different filename).
5. Enter a passphrase when prompted. It protects the private key even if the file leaks.
6. Confirm the files exist: ls -l ~/.ssh/id_ed25519 ~/.ssh/id_ed25519.pub.
7. Copy the public key to your server (ssh-copy-id or manual paste) before storing the private key inside SQLitePilot.

Windows 10/11 (PowerShell with built-in OpenSSH)

1. Launch PowerShell as your normal user.
2. Ensure the OpenSSH client feature is installed: Get-WindowsCapability -Online | Where-Object Name -like 'OpenSSH.Client*'.
3. Create the .ssh directory if it does not exist:

New-Item -ItemType Directory -Force "$env:USERPROFILE\.ssh" | Out-Null

4. Generate the key pair:

ssh-keygen -t ed25519 -a 100 -f "$env:USERPROFILE\.ssh\id_ed25519" -C "work-laptop-main"

5. Set NTFS permissions so only your account can read the private key:

icacls "$env:USERPROFILE\.ssh\id_ed25519" /inheritance:r /grant:r "$env:USERNAME":R

6. Display the public key so you can load it onto your server:

Get-Content "$env:USERPROFILE\.ssh\id_ed25519.pub"

7. When SQLitePilot asks for the private key, open the file in a plain-text editor such as Notepad and copy everything exactly.

Windows Subsystem for Linux (WSL)

• Follow the Linux instructions from inside your WSL distribution. The files live under /home/<user>/.ssh by default.
• If you need to use the same key from Windows tools, copy it to \wsl$\<Distro>\home\<user>\.ssh or export via cat ~/.ssh/id_ed25519.
• Remember that Windows and WSL maintain separate SSH agents; start the one that matches the environment where you run SQLitePilot uploads.

Git Bash (Windows)

1. Open Git Bash.
2. Run the same command as macOS/Linux: ssh-keygen -t ed25519 -a 100 -f ~/.ssh/id_ed25519 -C "work-laptop-main".
3. Git Bash maps ~/.ssh to C:\Users\<you>\.ssh, so the key is shared with other Windows tools automatically.
4. Use clip < ~/.ssh/id_ed25519.pub to copy the public key to the clipboard, or open the file via File Explorer.

Verify the key pair

After generating the key on any platform:

1. List the fingerprint to double-check the file: ssh-keygen -lf ~/.ssh/id_ed25519.pub (adjust the path on Windows).
2. Test SSH into a known server: ssh -i ~/.ssh/id_ed25519 user@server.
3. Once the remote host accepts the key, open SQLitePilot → Keys and paste the private key block exactly as it appears, including the BEGIN/END lines.

Troubleshooting tips

• ssh-keygen: command not found – install OpenSSH (Linux package openssh-client, macOS via Xcode Command Line Tools, Windows via optional features).
• Permission denied (publickey) – confirm the public key really lives in the server’s ~/.ssh/authorized_keys file and the permissions are 600.
• Clipboard mangled the key – recopy using a plain-text editor; never paste through rich-text apps like Word.
• Need multiple keys – generate additional files (for example ~/.ssh/id_ed25519_sqlitepilot) and label them with -C so you can tell them apart inside SQLitePilot.

With a fresh key pair safely stored in SQLitePilot, you are ready to upload SSH keys, create remote connections, and explore your databases without passwords.