RSA key pair generator

RSA is a public key algorithm: it uses two keys that only work together. The private key stays with you, and signs or decrypts. The public key can be shared with anyone, and verifies or encrypts. What one key does, only the other can undo.

Generating a pair means finding two large random primes, p and q. Their product n and the exponent e = 65537 form the public key. The private key adds the exponent d, which is easy to compute when you know p and q, and practically impossible from n alone: factoring a 2048-bit number is out of reach of every known computer.

2048 bits is the default of OpenSSL, ssh-keygen and most cloud providers, equivalent to 112 bits of security. NIST deems it safe until 2030.

3072 bits gives 128 bits of security, like AES-128, and is what NIST recommends past 2030. 4096 bits adds margin for keys that live long, like certificate authorities, at the cost of signing about 7 times slower than 2048 bits.

1024 bits is no longer safe: keep it for tests and for systems that accept nothing else.

The same key can be written several ways, and every library expects its own:

• BEGIN PRIVATE KEY is PKCS#8, the modern format of private keys, read by Node.js, Java, Go, Python and OpenSSL 3. BEGIN ENCRYPTED PRIVATE KEY is the same, encrypted with a passphrase.
• BEGIN RSA PRIVATE KEY is PKCS#1, the traditional OpenSSL format, and BEGIN RSA PUBLIC KEY its public counterpart.
• BEGIN PUBLIC KEY is SPKI(SubjectPublicKeyInfo), the format of public keys most tools mean by "PEM public key".
• ssh-rsa AAAA… is the OpenSSH public key, one line for authorized_keys.
• JWK is the JSON form of RFC 7517, used by JWT libraries and published in JWKS endpoints.

To create the same keys from a terminal, with OpenSSL 3:

# Private key, PKCS#8
openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out private.pem

# Public key, SPKI
openssl pkey -in private.pem -pubout -out public.pem

# Encrypt the private key with a passphrase
openssl pkey -in private.pem -aes-256-cbc -out encrypted.pem

# Convert to PKCS#1
openssl rsa -in private.pem -traditional -out private-rsa.pem

For SSH, ssh-keygen -t rsa -b 4096 writes the private key to ~/.ssh/id_rsa and the public key to ~/.ssh/id_rsa.pub. In Node.js, crypto.generateKeyPairSync("rsa", { modulusLength: 2048 }) does the same.

RSA is supported everywhere, from 20-year-old Java to hardware tokens, which makes it the safe choice when you don't control the other side. For new systems, Ed25519 is faster, with 32-byte keys and 64-byte signatures instead of 256 bytes for RSA 2048, and has fewer ways to be used wrong.

That's why LicenseManager signs its offline license tokens with Ed25519: your app verifies them with the public key, and nobody can forge one without the private key, which never leaves our servers. Paste a token in the JWT debugger to see how it's built.

Anyone holding the private key can sign as you or read what was encrypted for you. Store it in a secret manager or an environment variable, never in a Git repository or in an app you ship to customers. Encrypt it with a passphrase when it sits in a file, and restrict the file with chmod 600.

Only the public key goes in your app. If you sign licenses, your app holds the public key to check them: shipping the private key would let anyone create licenses.