SSH Key Generatorv2.0
Cryptographie OpenSSH Côté Client

Générer des Clés SSH Directement dans Votre Navigateur

Créez des paires de clés OpenSSH sécurisées avec Ed25519 ou RSA (2048–4096 bits). Toute la cryptographie s'exécute dans votre navigateur via WebCrypto. Les clés privées ne sont jamais transmises à un serveur.

Zéro Transmission Réseau
Format OpenSSH v1
Génération Instantanée
Sans Logs ni Cookies
Préréglages RapidesCliquez pour configurer automatiquement
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.
Centre d'Aide & Référence
Foire Aux Questions (FAQ)
Trouvez des réponses détaillées sur la génération de clés SSH, les algorithmes, la configuration des plateformes et la sécurité.
Q1Comment générer une clé SSH ?↓
Vous pouvez générer une clé SSH en ligne avec notre générateur dans le navigateur, ou dans un terminal avec ssh-keygen -t ed25519 -C "votre_email@exemple.com".
Q2Comment générer une clé SSH pour GitHub ?↓
Générez une clé Ed25519, copiez la clé publique (id_ed25519.pub), allez dans GitHub > Paramètres > Clés SSH et collez-la. Testez avec ssh -T git@github.com.
Q3Comment générer une clé SSH sous Windows ?↓
Dans PowerShell, lancez ssh-keygen -t ed25519. Copiez la clé publique avec : Get-Content ~/.ssh/id_ed25519.pub | Set-Clipboard.
Q4Comment générer une clé SSH sur Mac ?↓
Ouvrez le Terminal et exécutez ssh-keygen -t ed25519. Copiez-la avec pbcopy < ~/.ssh/id_ed25519.pub.
Q5Comment générer une clé SSH sous Linux ?↓
Ouvrez le terminal et exécutez ssh-keygen -t ed25519. Réglez les permissions avec chmod 600 ~/.ssh/id_ed25519.
Q6Comment générer une clé SSH pour GitLab ?↓
Créez une clé Ed25519, copiez la clé publique et ajoutez-la dans vos Paramètres utilisateur > Clés SSH sur GitLab.
Q7Comment générer une paire de clés SSH ?↓
Une paire comprend une clé privée (secrète) et une clé publique (déposée sur les serveurs). Créez-la en un clic avec notre outil.
Q8Comment générer une clé publique SSH ?↓
La clé publique est issue de la privée. Pour la recalculer : ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub.
Q9Comment générer une clé SSH Ed25519 ?↓
Ed25519 est l'algorithme recommandé en 2026. Choisissez 'Ed25519' dans notre outil ou tapez ssh-keygen -t ed25519.
Q10Existe-t-il un générateur de clé SSH gratuit ?↓
Oui, sshkeygenerator.com est 100% gratuit, open-source et sans publicité, s'exécutant entièrement en local.
Q11Qu'est-ce qu'une clé SSH ?↓
C'est un identifiant cryptographique asymétrique qui remplace les mots de passe pour sécuriser l'accès aux serveurs et dépôts Git.
Q12À quoi sert une clé SSH ?↓
Elle permet de se connecter aux serveurs distants, de pousser du code sur GitHub/GitLab, d'automatiser le CI/CD et de sécuriser les transferts SFTP.
Q13Comment créer une nouvelle clé SSH ?↓
Cliquez sur 'Générer Clé' ci-dessus ou lancez ssh-keygen -t ed25519 dans votre invite de commande.
Q14Peut-on générer une clé SSH en ligne en sécurité ?↓
Oui, car notre outil fonctionne exclusivement côté client avec l'API Web Crypto. Aucune clé privée ne quitte votre ordinateur.