Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Security

SSH Key Pair Generator

· Last updated:2026-06-24

Generate an SSH key pair (Ed25519 recommended, RSA 4096, or ECDSA P-256) with an OpenSSH-format public key ready for ~/.ssh/authorized_keys, a SHA256 fingerprint, and a PEM private key. Optional passphrase encryption. Runs locally.

Details

What this tool helps you do

Generates an SSH key pair and formats the public key in OpenSSH one-line format.

  • Algorithm:
  • Ed25519 (recommended) — modern, small, fast, the default in OpenSSH since 2015. 256-bit security.
  • RSA 4096 — large but widely compatible with very old SSH servers. Use only if Ed25519 isn't supported.
  • ECDSA P-256 — compact alternative; less common than Ed25519.
  • Comment: appended to the public key (e.g. alice@laptop). Helps identify the key in authorized_keys.
  • Passphrase: if provided, the private key is encrypted (AES-256-CBC, PKCS#8).

Outputs:

  • Public key in OpenSSH format (ssh-ed25519 AAAA... comment) — paste directly into ~/.ssh/authorized_keys.
  • SHA256 fingerprint (SHA256:...) for verifying the key over an insecure channel.
  • Private key in PKCS#8 PEM. (Node cannot emit the OpenSSH private-key container natively; convert with ssh-keygen -p if you need the BEGIN OPENSSH PRIVATE KEY format.)

Everything runs locally; keys never leave the request.

Execution

Run this tool

Fill in the form, run the tool, and review the result in one place.

Samples

Examples that match this tool

Related

Continue with connected tools and hubs

Written by the Elysia Tools team
Encryption40
Keys17
Public Key7
RSA5

Tool usage guide

Learn when to use this tool, what it supports, and how real users apply it.

Key facts

Category
Security
Input types
select, text
Output type
html
Sample coverage
4
API ready
Yes

Overview

The SSH Key Pair Generator allows you to securely generate cryptographic key pairs locally in your browser. It supports modern Ed25519, legacy-compatible RSA 4096, and ECDSA P-256 algorithms, providing an OpenSSH-formatted public key ready for your authorized_keys file, a SHA256 fingerprint, and a PKCS#8 PEM private key with optional passphrase encryption.

When to use

  • When you need to set up secure, passwordless SSH access to a remote server or cloud instance.
  • When you need to generate a modern Ed25519 or legacy RSA 4096 key pair quickly without using the command line.
  • When you want to generate keys locally in the browser to ensure your private keys never traverse the network.

How it works

  1. 1Select your preferred cryptographic algorithm, such as Ed25519, RSA 4096, or ECDSA P-256.
  2. 2Enter an optional comment to identify the key and a passphrase to encrypt the private key using AES-256-CBC.
  3. 3Click generate to run the cryptographic operations locally in your browser.
  4. 4Copy the resulting OpenSSH public key, SHA256 fingerprint, and PKCS#8 PEM private key.

Use cases

  • Provisioning a new Linux cloud server with a secure Ed25519 public key for SSH authentication.
  • Generating a legacy RSA 4096 key pair to connect to older network hardware or legacy servers.
  • Creating a passphrase-encrypted SSH key pair for secure deployment pipelines or automated scripts.

Examples

1. Setting up secure access to a new cloud VPS

Cloud Engineer

Background

A cloud engineer needs to configure SSH access for a newly deployed Ubuntu server on a public cloud provider.

Problem

They need a secure, modern SSH key pair with an identifying comment to append to the server's authorized keys.

How to use

Select the Ed25519 algorithm, enter 'admin@production-vps' in the comment field, leave the passphrase blank for automated access, and generate the keys.

Algorithm: Ed25519, Comment: admin@production-vps

Outcome

The tool outputs an Ed25519 public key ready for ~/.ssh/authorized_keys, a SHA256 fingerprint, and an unencrypted PKCS#8 PEM private key.

2. Generating an encrypted RSA key for legacy server compatibility

System Administrator

Background

An administrator needs to connect to an older legacy server that does not support modern Ed25519 keys.

Problem

They require a highly compatible RSA 4096 key pair encrypted with a passphrase for security compliance.

How to use

FAQ

Are my generated keys sent to a server?

No. All key generation runs locally in your browser and keys are never transmitted over the network.

Which algorithm should I choose?

Ed25519 is recommended for modern systems due to its speed and security, while RSA 4096 is best for legacy compatibility.

How do I use the public key on my server?

Copy the generated OpenSSH public key string and append it to the ~/.ssh/authorized_keys file on your remote server.

Why is the private key in PKCS#8 PEM format?

Browser-based generation outputs standard PKCS#8 PEM. You can convert it to the OpenSSH private key format using ssh-keygen -p if required.

Can I secure my private key with a password?

Yes. Entering a passphrase encrypts the private key using AES-256-CBC before outputting it.

Home
Tools3212
Samples593
Visualizations471
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact
Java

Android Image Processing Java Samples

Android Java image processing examples including reading/saving images, scaling, and format conversion

Kotlin

Android Image Processing Kotlin Samples

Android Kotlin image processing examples including reading/saving images, scaling, and format conversion

Python

Web Image Processing Python Samples

Web Python image processing examples using PIL/Pillow including reading, saving, resizing, and format conversion

Rust

Web Image Processing Rust Samples

Web Rust image processing examples including image read/save, scaling, and format conversion

Security

PKCE Code Verifier & Challenge Generator

Generate, validate and verify OAuth2 / OIDC PKCE (RFC 7636) code_verifier and S256 code_challenge pairs. Three modes: (1) generate a fresh verifier + challenge from cryptographically secure random bytes at 256/384/512/768-bit entropy, (2) audit a verifier you already have against the RFC — length (43–128), charset [A-Za-z0-9-._~] and ≥256-bit entropy, and (3) verify a verifier/challenge pair by recomputing BASE64URL(SHA256(verifier)). Optionally build the full authorization-request URL and token-exchange body. Complements the generic nonce-generator (which only emits a verifier+challenge pair) with RFC-compliance auditing and pair verification.

Security

HMAC Generator & Verifier

Compute an HMAC message-authentication signature over a message + shared secret using SHA-1/SHA-2/SHA-3/BLAKE2, or verify an incoming signature against the secret — with webhook presets for Stripe / Slack / GitHub and constant-time comparison

Text Processing

Markdown Table Generator

Generate formatted Markdown tables from CSV, JSON, or array data with alignment, header styles, width control, and merge hints

Security

TOTP / HOTP Offline Code Generator

Generate RFC 6238 TOTP (time-based, 6/8 digits, 30/60s step) and RFC 4226 HOTP (counter-based) one-time passwords from a base32 shared secret, fully offline with HMAC-SHA1/256/512, plus an otpauth:// URI for importing into Google Authenticator / Authy

Select the RSA 4096 algorithm, enter a secure passphrase, and generate the key pair.

Algorithm: RSA 4096, Passphrase: [secure_passphrase]

Outcome

The tool generates a 4096-bit RSA public key and an AES-256-CBC encrypted PKCS#8 PEM private key.