SSH Key Generatorv2.0
OpenSSH Client-Side Cryptography

Generate SSH Keys Directly in Your Browser

Securely create OpenSSH key pairs with Ed25519 or RSA (2048–4096 bit). Cryptographic generation occurs entirely in your browser using hardware-accelerated WebCrypto. Private keys are never transmitted to any server.

Zero Network Transmission
OpenSSH v1 Format
Instant Generation
No Logs / No Cookies
Quick Workflow PresetsClick any preset to auto-configure
e.g. email or machine
Quick:

Protects private key with AES-256-CTR and bcrypt. Recommended for sensitive laptops & workstations.

Keys are calculated entirely in memory on your device. Zero telemetry.
SSH Key Pair ReadyED25519 (256-bit)Unencrypted

Public key can be safely shared. Keep your private key confidential.

Public Keyid_ed25519.pub
OpenSSH Single Line

Paste this key into ~/.ssh/authorized_keys on servers or in GitHub Settings > SSH Keys.

Private Keyid_ed25519
🔒 Hidden for privacy (Click Reveal to view)

Save to ~/.ssh/id_ed25519. Permissions must be restricted: chmod 600.

Cryptographic Fingerprints & Specifications
SHA-256 Fingerprint (Default OpenSSH)
SHA256:----------------------------------------
MD5 Fingerprint (Legacy Hex)
--:--:--:--:--:--:--:--:--:--:--:--:--:--:--:--
Equivalent CLI Commands & SetupCopy & run in terminal
Local ssh-keygen Equivalent Command:
Fix ~/.ssh Permissions (chmod 600):
Add Public Key to Remote Server (single line):
Step-by-Step Integration
How to Use Your SSH Keys
Select your target service or infrastructure platform below for copy-paste instructions pre-filled with your generated key.
Connecting to GitHub with SSH
Open GitHub SSH Settings ↗
  1. Copy your generated public key using the Copy Public Key button above.
  2. Navigate to GitHub Settings > SSH and GPG keys, then click New SSH Key.
  3. Give your key an identifiable Title (e.g. MacBook Pro 2026), select Authentication Key as key type, and paste your public key into the Key field.
  4. Test your connection in your local terminal:
Verification Command:
ssh -T git@github.com
Expected response: "Hi username! You've successfully authenticated, but GitHub does not provide shell access."
Configuration Generator
SSH Config Builder (~/.ssh/config)
Avoid typing long IP addresses, ports, and identity flags. Configure aliases for instant logins via simple commands like ssh my-server.
Generated ~/.ssh/config Stanza
Then simply connect using:
ssh prod-server
Technical Evaluation
Ed25519 vs RSA (2048 / 4096) Comparison
Ed25519 was introduced into OpenSSH 6.5 (2014) and is the current industry gold standard. Use this comparison to decide which algorithm fits your security policies.
Criteria
Ed25519RECOMMENDED
RSA 4096-bitRSA 2048-bit (Minimum)
Algorithm FamilyElliptic Curve (Twisted Edwards / Curve25519)Integer FactorizationInteger Factorization
Key Size (Public / Private)256 bits (Ultra compact 68-char public key)4096 bits (Large ~736-char public key)2048 bits (Medium ~372-char public key)
Effective Security Level~128-bit security (Exceeds NIST Level 1)~140-bit security~112-bit security (Borderline legacy)
Performance & Speed⚡ ~10x Faster(Sub-millisecond verification & signing)Significantly slower; high CPU cost during keygenModerate speed
Side-Channel ResistanceConstant-time by design (Immune to cache-timing attacks)Requires mathematical blinding techniquesRequires mathematical blinding techniques
Ecosystem CompatibilityGitHub, GitLab, AWS, Bitbucket, macOS, Ubuntu 16.04+, OpenSSH 6.5+Universal (Works on obsolete servers from 2000+)Universal
Best ForAll modern servers, Git repositories, CI/CD, Kubernetes & developersOlder enterprise servers that reject elliptic curve algorithmsOnly legacy environments where 4096-bit is unsupported
Security & Cryptographic Architecture
Client-Side Isolation & Zero-Trust Guarantee
We believe you should never trust a remote server with your private cryptographic keys. Here is exactly how our browser-based generation architecture protects your identity.
Hardware-Backed Entropy
Key generation relies on the native browser crypto.getRandomValues API, drawing entropy directly from your operating system's cryptographic random pool (/dev/urandom on Unix and CryptGenRandom on Windows).
Zero Network Roundtrips
Open your browser's Developer Tools (F12) and inspect the Network tab. Click "Generate Key Pair" and observe: zero HTTP POST or GET requests are dispatched. Your private key exists solely in transient browser memory until you close the tab.
Air-Gapped Offline Ready
For ultra-high-security environments, load this web application once, disconnect your Wi-Fi or unplug your ethernet cable, and generate your keys in an air-gapped environment. The cryptographic engine runs seamlessly without an active internet connection.
SSH Permissions & Troubleshooting Guide
1. "Permissions 0644 for 'id_rsa' are too open" Error
OpenSSH will flatly refuse to use private keys if other users on the operating system have read permissions. Fix this instantly in your terminal:
chmod 700 ~/.ssh && chmod 600 ~/.ssh/id_ed25519
2. Multiple SSH Keys for Different Accounts
If you have separate GitHub accounts for work and personal projects, create two keys and route them in your ~/.ssh/config:
Host github-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_work
3. When to Always Use a Passphrase
Always set a passphrase for keys on laptops and developer machines. If your device is misplaced or compromised, an encrypted key gives you time to revoke authorization before an attacker can crack it.
4. When Unencrypted Keys are Acceptable
Unencrypted keys are standard for non-interactive CI/CD deployment runners, automated backup cron jobs, and Terraform / Ansible automation where no human is present to type a passphrase.
Comprehensive Documentation
The Complete Guide to Generate SSH Key Pairs (Ed25519 & RSA)
Whether you need a direct generate ssh key github workflow, configure a production Linux cluster, or set up secure authentication on Windows, macOS, or Ubuntu, having a dependable SSH key generator is essential for modern software development and systems engineering.
What Is an SSH Key and How Does an SSH Key Generator Work?
An SSH (Secure Shell) key is an access credential used by the SSH protocol to securely authenticate users and systems without transmitting plain-text passwords over an untrusted network. When you generate SSH key pair credentials, the system creates two mathematically bound cryptographic files:
Private Key (Identity)
Remains strictly on your local computer or workstation (~/.ssh/id_ed25519 or ~/.ssh/id_rsa). It should never be shared, uploaded, or exposed. It acts as the digital secret that proves your ownership of the matching public key.
Public Key (Lock)
When you generate SSH public key credentials (id_ed25519.pub), this file is uploaded to external destinations such as GitHub, GitLab, Bitbucket, AWS EC2, or appended to ~/.ssh/authorized_keys on remote servers.
When authenticating, the server encrypts a challenge message with your public key, and only your private key can mathematically decrypt it to verify your identity. Because this browser-based SSH key generator leverages the native Web Crypto API and client-side JavaScript, the cryptographic key generation happens completely in your browser's private memory—ensuring your private keys are never transmitted to any third-party server.
Cryptographic Standard
Why You Should Generate Ed25519 SSH Key Pairs in 2026
Historically, RSA (Rivest–Shamir–Adleman) was the default algorithm for SSH connections. However, modern security engineering strongly advocates to generate SSH key Ed25519 pairs for virtually all new infrastructure. Ed25519 relies on Edwards-curve Digital Signature Algorithm (EdDSA) over Curve25519, offering significant architectural advantages:
  • Superior Security with Compact Size: A 256-bit Ed25519 key delivers approximately 128 bits of symmetric security, which outperforms a legacy 2048-bit RSA key and rivals a heavy 4096-bit RSA key. The public key is only 68 characters long, making it easy to paste without formatting errors.
  • Blazing Performance: When you generate ed25519 ssh key files, signature creation and cryptographic verification happen up to 10 times faster than RSA, significantly reducing SSH connection latency and CPU overhead on busy servers.
  • Constant-Time Operation: Unlike RSA and older ECDSA curves, Ed25519 was designed specifically to be constant-time, granting inherent immunity against side-channel and cache-timing attacks.
  • Universal Modern Adoption: Supported by OpenSSH 6.5+ (shipped in 2014), GitHub, GitLab, Bitbucket, Ubuntu, Debian, Fedora, Arch Linux, and macOS.
You should generally only choose RSA if you are required to support legacy hardware appliances, enterprise firewalls, or archaic Linux distributions that have not been updated in over a decade.
How to Generate SSH Key on Windows, Mac, Linux, and Ubuntu
While our online ssh key generator allows you to create keys instantly with one click, understanding how to generate ssh key pairs natively from your terminal is an essential developer skill. Here are the exact command equivalents across each major operating system:
Generate SSH Key Windows (10/11 & PowerShell)
Windows
Windows 10 and 11 feature a built-in OpenSSH Client. Open PowerShell or Windows Terminal and execute:
ssh-keygen -t ed25519 -C "your_email@example.com"
Keys will be stored under C:\Users\username\.ssh\id_ed25519. To copy your public key to clipboard:
Get-Content ~/.ssh/id_ed25519.pub | Set-Clipboard
Generate SSH Key Mac (macOS Terminal)
macOS
To generate ssh key mac users can open the Terminal.app (Command + Space > Terminal) and enter:
ssh-keygen -t ed25519 -C "your_email@example.com"
Copy your public key directly to your macOS clipboard with pbcopy:
pbcopy < ~/.ssh/id_ed25519.pub
Generate SSH Key Linux (Debian, RHEL, Arch)
Linux
To generate ssh key linux administrators use the standard OpenSSH suite present on nearly every distribution:
ssh-keygen -t ed25519 -C "admin@yourdomain.com"
Copy public key to a remote server using ssh-copy-id:
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server_ip
Generate SSH Key Ubuntu (20.04, 22.04, 24.04 LTS)
Ubuntu
On Ubuntu, you can ensure OpenSSH is installed and generate ssh key ubuntu commands in seconds:
sudo apt update && sudo apt install -y openssh-client
ssh-keygen -t ed25519 -C "ubuntu-user@server"
Always verify that permissions on your private key are strictly locked:
chmod 700 ~/.ssh && chmod 600 ~/.ssh/id_ed25519
How to Git Generate SSH Key Credentials for GitHub & GitLab
Password authentication over HTTPS for Git was deprecated by GitHub in August 2021. Today, developers must use personal access tokens or git generate ssh key authentication. SSH keys are the preferred industry standard because they never expire unless revoked, work smoothly with background Git operations, and can be easily managed through SSH agents.
Generate SSH Key for GitHub
  1. Use the generator above to create an Ed25519 key pair.
  2. Click Copy Public Key.
  3. In GitHub, click your profile icon > Settings > SSH and GPG keys.
  4. Click New SSH Key, enter a descriptive title, select Authentication Key, and paste.
  5. Verify your authentication:
ssh -T git@github.com
Generate SSH Key for GitLab
  1. To gitlab generate ssh key pairs, select Ed25519 with your GitLab email comment.
  2. Copy the generated public key.
  3. In GitLab, go to Preferences (or User Settings) > SSH Keys.
  4. Paste your key into the text field, select an optional expiration date, and click Add key.
  5. Verify your connection:
ssh -T git@gitlab.com
Enterprise Best Practices for SSH Key Pair Security
Generating an SSH key is only the first step; maintaining proper cryptographic hygiene protects your company's servers and source code repositories from compromise. Keep the following rules in mind:
1. Dedicated Keys Per Device
Never copy your private key between machines. Generate an independent key pair on your work laptop, home desktop, and CI servers. This prevents lateral movement if one machine is lost or compromised.
2. Enforce Passphrases
Always protect interactive developer private keys with a passphrase. Our tool enables AES-256-CTR encryption with bcrypt key derivation so your key file is secure even if an attacker steals your disk backup.
3. Audit authorized_keys
Regularly inspect the ~/.ssh/authorized_keys file on production servers. Remove stale keys from employees who have departed or systems that have been decommissioned.
Help Center & Reference
Frequently Asked Questions (FAQ)
Find detailed answers to common questions about generating SSH keys, algorithms, platform setup, and security best practices.
Q1How to generate an SSH key?↓
You can generate an SSH key in two easy ways: 1) Online: Use our free, client-side SSH key generator above to create an Ed25519 or RSA key pair instantly in your browser with zero server transmission. 2) Via Terminal: Open your command line and run ssh-keygen -t ed25519 -C "your_email@example.com". Follow the prompts to save the key to ~/.ssh/id_ed25519 and optionally enter a passphrase.
Q2How to generate SSH key for GitHub?↓
To generate an SSH key for GitHub: 1) Generate an Ed25519 key pair using this tool or run ssh-keygen -t ed25519 -C "your_email@example.com". 2) Copy your public key (id_ed25519.pub). 3) Go to GitHub > Settings > SSH and GPG keys > New SSH key. 4) Select Authentication Key, enter a title, and paste the public key. 5) Test in terminal with ssh -T git@github.com.
Q3How to generate an SSH key on Windows?↓
On Windows 10 and 11, open PowerShell or Windows Terminal and execute: ssh-keygen -t ed25519 -C "your_email@example.com". Press Enter to accept the default file location (C:\Users\username\.ssh\id_ed25519). Copy your public key to clipboard with: Get-Content ~/.ssh/id_ed25519.pub | Set-Clipboard.
Q4How to generate an SSH key on Mac?↓
To generate an SSH key on macOS: 1) Open Terminal (Cmd + Space, type Terminal). 2) Run ssh-keygen -t ed25519 -C "your_email@example.com". 3) Press Enter to save in the default location (~/.ssh/id_ed25519). 4) Copy the public key directly to your macOS clipboard with: pbcopy < ~/.ssh/id_ed25519.pub.
Q5How to generate an SSH key on Linux?↓
On Linux (Debian, Ubuntu, Fedora, CentOS, Arch), open your terminal and run: ssh-keygen -t ed25519 -C "your_email@example.com". Set proper permissions with chmod 600 ~/.ssh/id_ed25519. Then copy your public key to any remote server using ssh-copy-id -i ~/.ssh/id_ed25519.pub username@server-ip.
Q6How to generate SSH key for GitLab?↓
To generate an SSH key for GitLab: 1) Select Ed25519 in our generator or run ssh-keygen -t ed25519 -C "gitlab_email@example.com". 2) Copy your public key. 3) In GitLab, navigate to User Settings > SSH Keys. 4) Paste the public key, set an optional expiration date, and click Add key. 5) Verify connection with ssh -T git@gitlab.com.
Q7How to generate an SSH key pair?↓
An SSH key pair consists of two mathematically linked files: a private key (kept strictly confidential on your computer) and a public key (placed on servers or services you access). You can generate an SSH key pair online using our web generator by selecting Ed25519 or RSA and clicking 'Generate SSH Key Pair', or through terminal with the standard ssh-keygen command.
Q8How to generate an SSH public key?↓
When you generate an SSH key pair, the public key (.pub) is automatically derived from the private key. If you have an existing private key and need to regenerate its corresponding public key, run: ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub.
Q9How to generate an Ed25519 SSH key?↓
Ed25519 is an Edwards-curve algorithm (Curve25519) that provides ~128-bit security with compact 256-bit keys and faster performance than RSA. To generate an Ed25519 SSH key online, select 'Ed25519 (Recommended)' in our generator above. In a terminal, run: ssh-keygen -t ed25519 -C "your_comment".
Q10Is there a free SSH key generator?↓
Yes! sshkeygenerator.com is a completely free, open online SSH key generator. It runs 100% in your browser using the native Web Crypto API, requires no account or registration, displays no ads, and never transmits your private keys to any server.
Q11What is an SSH key?↓
An SSH key is an access credential for the Secure Shell (SSH) network protocol. It uses asymmetric public-key cryptography to authenticate remote systems, servers, and Git repositories securely without sending passwords over the network. It eliminates vulnerability to password guessing, dictionary, and brute-force attacks.
Q12What is an SSH key used for?↓
SSH keys are used to: 1) Log into remote Linux, Unix, and macOS servers without passwords. 2) Securely authenticate Git commits, pushes, and pulls with GitHub, GitLab, and Bitbucket. 3) Automate CI/CD deployments and server management via Ansible, Terraform, or Docker. 4) Transfer files securely via SFTP and SCP. 5) Connect to cloud instances on AWS EC2, Google Cloud, Azure, and DigitalOcean.
Q13How do I create a new SSH key?↓
To create a brand new SSH key: 1) Click 'Generate SSH Key Pair' in our web tool above, or run ssh-keygen -t ed25519 -f ~/.ssh/new_key_id -C "identifier" in terminal. 2) Save the generated private key to your machine with permissions chmod 600. 3) Add the public key to the remote service or server's ~/.ssh/authorized_keys.
Q14Can I generate an SSH key online?↓
Yes, you can safely generate an SSH key online if the tool performs all cryptographic operations client-side. Our tool uses the browser's hardware-accelerated Web Crypto API, meaning the private and public keys are created purely in your browser's local memory and are never uploaded or saved to remote servers. You can even disconnect your internet connection before clicking generate for complete air-gapped security.