Elysia Tools

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

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Security

RSA Key Pair Generator

· Last updated:2026-06-24

Generate an RSA key pair (2048/3072/4096-bit) as PEM-encoded public and private keys. Optionally encrypt the private key with a passphrase. PKCS#8 (recommended) or PKCS#1 private key format. Everything runs locally.

Details

What this tool helps you do

Produces a matching RSA public/private key pair using Node's crypto.generateKeyPairSync().

  • Key size: 2048 (the modern baseline), 3072, or 4096 bits. Larger = more security but slower. 2048 is fine for most uses; use 4096 for long-term protection.
  • Private key format:
  • PKCS#8 (recommended) — generic format, works everywhere, supports passphrase encryption.
  • PKCS#1 — RSA-specific (older), label RSA PRIVATE KEY. Cannot be encrypted with a passphrase in this tool.
  • Passphrase: if provided, the private key is encrypted (AES-256-CBC) and cannot be used without it.

The public key is always SPKI format (PUBLIC KEY).

Use cases: setting up HTTPS, JWT signing keys, SSH from RSA, learning asymmetric crypto. The keys are generated locally and never transmitted.

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
Public Key7
Private Key6
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 RSA Key Pair Generator allows you to securely generate PEM-encoded public and private keys directly in your browser. Supporting key sizes of 2048, 3072, and 4096 bits, the tool lets you choose between PKCS#8 and PKCS#1 private key formats, with the option to encrypt your private key using a passphrase. Because all cryptographic operations run locally, your keys are never transmitted over the network.

When to use

  • When you need to generate secure SSH keys or SSL/TLS certificates for server authentication.
  • When setting up token-based authentication systems that require RSA public/private key pairs for JWT signing and verification.
  • When you need to quickly generate cryptographic keys for local development or testing without exposing sensitive data to external servers.

How it works

  1. 1Select your desired key size (2048, 3072, or 4096 bits) and choose between the PKCS#8 or PKCS#1 private key format.
  2. 2Optionally enter a passphrase to encrypt the private key using AES-256-CBC.
  3. 3Click generate to run the cryptographic function locally in your browser and instantly view the copy-ready PEM-encoded public and private keys.

Use cases

  • Generating RSA key pairs for signing and verifying JSON Web Tokens (JWT) in web applications.
  • Creating public and private key pairs to configure secure SSH access to remote servers.
  • Setting up local SSL/TLS certificates for development environments requiring HTTPS.

Examples

1. Generate Standard JWT Signing Keys

Backend Developer

Background

A developer needs to configure an authentication service that signs JWTs using asymmetric RSA encryption.

Problem

Needs a secure, unencrypted 2048-bit RSA key pair in PKCS#8 format for rapid integration into a local configuration file.

How to use

Select 2048 bits for the key size, choose PKCS#8 as the format, leave the passphrase field blank, and generate the keys.

Key size: 2048, Format: PKCS#8, Passphrase: (empty)

Outcome

Instantly copies the PEM-encoded public and private keys to paste into the application's environment variables.

2. Secure SSH Key Generation with Passphrase

System Administrator

Background

An administrator is setting up access to a production server and requires a highly secure, encrypted private key.

Problem

Needs a 4096-bit RSA key pair where the private key is encrypted to prevent unauthorized access if the file is compromised.

How to use

Select 4096 bits for maximum security, choose PKCS#8, enter a strong passphrase in the input field, and generate the pair.

FAQ

Are my generated keys secure?

Yes. The keys are generated entirely in your browser using local cryptographic APIs and are never sent to any server.

What is the difference between PKCS#8 and PKCS#1?

PKCS#8 is a modern, generic standard that supports passphrase encryption in this tool, while PKCS#1 is an older, RSA-specific format.

Which key size should I choose?

2048 bits is the standard baseline for most applications, while 4096 bits offers stronger, long-term security at the cost of slower performance.

Can I encrypt a PKCS#1 private key with a passphrase here?

No, passphrase encryption in this tool is only supported for the PKCS#8 format.

What format is the generated public key?

The public key is always generated in the standard SPKI format, labeled as 'PUBLIC KEY'.

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

Env File Secret Rotation Planner

Paste a .env file and get a staged secret-rotation plan. Detects database URLs, API keys, auth tokens, private keys, cloud credentials, payment keys and encryption secrets, scores each by exposure and age, and schedules them across a 4-week rotation timeline with a dual-key checklist and a generated .env.example. Optional last-rotated dates and a configurable cadence (30/90/180/365 days) drive compliance scoring.

Security

ML-KEM / Kyber Keypair & Encapsulation Tester

Generate ML-KEM-512/768/1024 (FIPS 203 / CRYSTALS-Kyber) keypairs, encapsulate a random shared secret against the public key, decapsulate it with the private key, and verify both sides match — with the exact wire sizes of all three parameter sets checked live against the standard.

Security

AGEX Keypair Generator

Generate an Ed25519 keypair for AGEX bundle signing and verification

Security

Key Pair Generator

Generate public/private key pairs for various cryptographic algorithms

Key size: 4096, Format: PKCS#8, Passphrase: 'SuperSecurePassword123'

Outcome

Generates a 4096-bit public key and an AES-256-CBC encrypted PKCS#8 private key block.