SSH Key Generatorv2.0
Criptografia OpenSSH no Navegador

Gerar Chaves SSH Diretamente no seu Navegador

Crie pares de chaves OpenSSH seguras com Ed25519 ou RSA (2048–4096 bits). Toda a criptografia roda localmente com WebCrypto. As chaves privadas nunca são enviadas para servidores.

Zero Transmissão de Rede
Formato OpenSSH v1
Geração Instantânea
Sem Registros nem Cookies
Modelos RápidosClique em qualquer modelo para autoconfigurar
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.
Central de Ajuda
Perguntas Frequentes (FAQ)
Respostas detalhadas sobre geração de chaves SSH, algoritmos, configurações de plataformas e práticas de segurança.
Q1Como gerar uma chave SSH?↓
Gere online nesta ferramenta com segurança ou use o terminal com o comando ssh-keygen -t ed25519 -C "seu_email@exemplo.com".
Q2Como gerar chave SSH para o GitHub?↓
1) Crie uma chave Ed25519. 2) Copie a chave pública (id_ed25519.pub). 3) Cole em GitHub > Settings > SSH and GPG keys. 4) Teste com ssh -T git@github.com.
Q3Como gerar uma chave SSH no Windows?↓
Abra o PowerShell e execute: ssh-keygen -t ed25519. Copie a chave com: Get-Content ~/.ssh/id_ed25519.pub | Set-Clipboard.
Q4Como gerar uma chave SSH no Mac?↓
No Terminal do macOS, digite: ssh-keygen -t ed25519. Copie para a área de transferência com: pbcopy < ~/.ssh/id_ed25519.pub.
Q5Como gerar uma chave SSH no Linux?↓
No Linux, execute ssh-keygen -t ed25519, restrinja permissões com chmod 600 ~/.ssh/id_ed25519 e envie para o servidor com ssh-copy-id.
Q6Como gerar chave SSH para o GitLab?↓
Gere um par Ed25519, copie a chave pública e adicione em Configurações do Usuário > Chaves SSH no GitLab.
Q7Como gerar um par de chaves SSH?↓
O par consiste em uma chave privada (secreta) e uma pública (compartilhada). Gere online com 1 clique nesta ferramenta.
Q8Como gerar uma chave pública SSH?↓
Recupere a chave pública a partir da privada com: ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub.
Q9Como gerar uma chave SSH Ed25519?↓
Ed25519 é o padrão moderno de 256 bits em curva elíptica. Selecione 'Ed25519' acima ou use ssh-keygen -t ed25519.
Q10Existe um gerador de chaves SSH gratuito?↓
Sim, sshkeygenerator.com é 100% gratuito, sem anúncios e com execução inteiramente local no navegador.
Q11O que é uma chave SSH?↓
É uma credencial criptográfica assimétrica que substitui senhas convencionais para acesso seguro a servidores e repositórios Git.
Q12Para que serve uma chave SSH?↓
Serve para logins seguros em servidores Linux, envio de código no GitHub/GitLab, automação CI/CD e conexões SFTP.
Q13Como criar uma nova chave SSH?↓
Clique em 'Gerar Chave' acima ou execute ssh-keygen -t ed25519 no seu terminal.
Q14É seguro gerar chave SSH online?↓
Sim, desde que a ferramenta use a Web Crypto API no navegador sem fazer envios de rede, exatamente como nosso site funciona.