RSA Key Generator

The RSA Key Generator creates asymmetric cryptographic key pairs for signing, encryption, TLS certificates, SSH authentication, JWT signing, and API authentication. Supports RSA (2048, 3072, 4096-bit) — the traditional standard, and Elliptic Curve (P-256, P-384, P-521, Ed25519) — the modern alternative with smaller keys and faster operations at equivalent security. Output includes both private key (PEM-encoded PKCS#8 by default) and public key (PEM-encoded SPKI or OpenSSH format). Keys are generated using the browser Web Crypto API — the same battle-tested cryptography used by TLS connections. Private keys never leave your browser.

Asymmetric keys power modern authentication: SSH logins (no password), TLS certificates (HTTPS), JWT token signing (RS256/ES256), code signing (npm, Apple, Google), cryptocurrency wallets (Bitcoin, Ethereum), and email encryption (PGP). Correctly generating keys matters — an RSA 1024-bit key is breakable; RSA 2048 is secure until ~2030; 4096 is future-proof for longer. Elliptic Curve keys (P-256) offer equivalent security to RSA 3072 with much smaller keys and faster operations. This tool makes correct key generation simple, without installing OpenSSL or learning its arcane CLI syntax.

Asymmetric (public-key) cryptography uses key pairs: private key (kept secret) and public key (shared freely). The keys are mathematically related but one cannot derive the private from the public.

RSA (Rivest-Shamir-Adleman, 1977):

Based on the difficulty of factoring products of large prime numbers. Most widely-deployed asymmetric algorithm.

Key sizes:

| Size | Bits | Security level | Performance |
|---|---|---|---|
| 2048 | 2048 | Secure until ~2030 | Fast |
| 3072 | 3072 | Secure until ~2050 | Moderate |
| 4096 | 4096 | Long-term secure | Slow |

Elliptic Curve Cryptography:

Based on algebraic structure of elliptic curves. Smaller keys, faster operations, equivalent security.

EC key sizes vs RSA equivalents:

| EC Curve | Bits | Equivalent RSA | Status |
|---|---|---|---|
| P-256 | 256 | RSA 3072 | Standard, widely supported |
| P-384 | 384 | RSA 7680 | Higher security |
| P-521 | 521 | RSA 15360 | Maximum security |
| Ed25519 | 256 | RSA 3072 | Modern best, fastest, smallest signatures |

Output formats:

PEM (Base64-encoded DER with headers):
``
-----BEGIN PRIVATE KEY-----
MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQ...
-----END PRIVATE KEY-----
``

PKCS#8 (modern private key format): BEGIN PRIVATE KEY
PKCS#1 (RSA-specific legacy): BEGIN RSA PRIVATE KEY
SPKI (modern public key format): BEGIN PUBLIC KEY
PKCS#1 Public (RSA-specific legacy): BEGIN RSA PUBLIC KEY

OpenSSH format (for ssh-copy-id, authorized_keys):
``
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC... user@host
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI... user@host
``

Typical use cases and recommended algorithms:

| Use case | Algorithm | Why |
|---|---|---|
| SSH server auth | Ed25519 or RSA 4096 | Ed25519 is modern; RSA 4096 for compatibility |
| TLS certificates | RSA 2048 or ECDSA P-256 | Both widely supported |
| JWT signing | ES256 (P-256) | Modern, small signatures |
| Code signing | RSA 4096 | Long-term stability |
| Git commit signing | Ed25519 | Modern, fast |
| Bitcoin/Ethereum | ECDSA secp256k1 | Blockchain standard |

Key pair relationship:

- Private key signs and decrypts (only you).
- Public key verifies signatures and encrypts messages to you (anyone).
- Loss of private key = lose access (passphrase-protect for physical theft).
- Public key leak is fine (that is what public means).

Passphrase protection:

Private keys can be encrypted with a passphrase. Required to use the key:

``
-----BEGIN ENCRYPTED PRIVATE KEY-----
MIIFLTBXBgkqhkiG9w0BBQ0wSjApBgkqhkiG9w0BBQwwHAQI...
-----END ENCRYPTED PRIVATE KEY-----
``

This tool generates unencrypted keys by default. Encrypt with OpenSSL if needed:
openssl pkcs8 -in key.pem -topk8 -v2 aes-256-cbc -out encrypted.pem

Security best practices:

- Never commit private keys to git (add *.pem, *.key to .gitignore).
- Set proper permissions: chmod 600 key.pem (owner read/write only).
- Rotate periodically — especially after any suspected compromise.
- Use hardware keys for high-value keys (YubiKey, AWS KMS, HSMs).
- Backup securely — loss of key = loss of access.

RSA vs EC vs Ed25519: RSA — traditional, widely supported, larger keys. EC (P-256/P-384) — modern, smaller, faster, same security. Ed25519 — newest, fastest, smallest signatures, best for SSH. Modern recommendation: Ed25519 for SSH, ECDSA for most else, RSA for legacy compatibility.

RSA-2048 vs RSA-4096: 2048 is secure until ~2030 with current technology. 4096 is future-proof. Performance: 4096 is ~5x slower for signing. Choose 4096 for long-lived keys (root CAs, code signing). Use 2048 for tokens (short-lived).

PKCS#8 vs PKCS#1: PKCS#8 is modern, algorithm-agnostic (BEGIN PRIVATE KEY). PKCS#1 is RSA-specific legacy (BEGIN RSA PRIVATE KEY). Modern libraries prefer PKCS#8. Conversion: openssl pkcs8 -in old.pem -topk8 -nocrypt -out new.pem.

PEM vs DER vs OpenSSH: PEM is Base64-encoded DER with headers (text). DER is binary. OpenSSH is a single-line text format for SSH keys. Different tools expect different formats; all are equivalent.

Web Crypto vs OpenSSL: Web Crypto (this tool) is in-browser JavaScript, no install. OpenSSL is CLI, more features (passphrase encryption, conversions). Both produce compatible keys.

Encrypted vs unencrypted private keys: Encrypted private keys need a passphrase to use. Higher security (theft needs passphrase too). This tool generates unencrypted; encrypt with OpenSSL after if needed.