Generate an RSA Key Pair — Free 2048/4096-bit PEM Generator

Every time you secure a connection, sign a JWT, or authenticate over SSH, an RSA key pair is working silently in the background. This RSA key pair generator gives you cryptographically secure public and private keys instantly — generated entirely in your browser so your key material never leaves your device. Whether you are a developer integrating public-key encryption into an application, a student exploring computer science concepts, or a systems engineer setting up a secure tunnel, understanding what your generated keys do — and how to handle them safely — is the difference between robust data security and a critical vulnerability.

What Is an RSA Key Generator Producing?

RSA, short for Rivest–Shamir–Adleman (rivest-shamir-adleman), is the most widely deployed public-key cipher system in internet protection. At its core, the method relies on two mathematically related keys — a shareable key and a secret key — whose relationship is easy to compute in one direction but computationally infeasible to reverse without the other half. That one-way mathematical relationship is what gives RSA its strength: even with massive computing power, deriving one key from the other at an adequate key length is not practically achievable.

The RSA method depends on the difficulty of factoring the product of two very large prime numbers. The rsa modulus — that product — forms the foundation of both keys. Its bit length, known as the modulus size, directly determines cipher strength and is what you select before you generate keys.

How Asymmetric Encryption Works With a Private Key

Asymmetric encoding uses a pair of mathematically related keys rather than a single shared secret. Any message ciphered with one key can only be deciphered with the other, which eliminates the need to securely exchange a shared secret before communication begins. This approach is ideal for protecting data across a large number of parties because each person only needs a single key pair — publish the public component freely and keep the secret half locked away. RSA underpins the secure browser connections your device makes every day, as well as transport-layer handshakes, secure shell login, and dozens of other protected communication protocols.

The dual-key method also scales elegantly: a sender can protect sensitive content with the recipient's shareable key, and only the secret-key holder can recover it — a process known as data decryption. Conversely, a signer can produce a digital signature with their secret key, and anyone holding the corresponding shareable key can perform validity checking to confirm authenticity. This dual capability — ciphering and attesting — makes RSA the backbone of public key infrastructure (PKI) and modern data protection.

Public Key Roles vs. Private Key Roles

Understanding which key does what prevents costly configuration mistakes:

• Public key — freely distributable; used to protect data or verify signatures. Share it with anyone who needs to send you secured messages or confirm your identity. Distributing your shareable key carries no risk.
• Private key — must remain secret at all times; used to recover received ciphertext or to sign documents and messages. Safeguarding your secret key is paramount: if it is compromised, every message secured for you and every signature you have produced is at risk.

The RSA relationship between the two keys is strictly one-directional for protective purposes. You can freely derive the shareable key from the secret key (as the openssl rsa command does), but you cannot derive the secret key from the shareable key — that is precisely what makes the cipher system robust. Never share your secret key or transmit it over a network.

RSA Key Size Comparison — Free RSA Key Pair Generator Reference Table

Choosing the right key length is a balance between cipher strength, performance, and compatibility. The key length comparison table below summarises the trade-offs for each supported bit length, reflecting industry and regulatory recommendations:

PEM, PKCS#1, and PKCS#8 Format Details

PEM (Privacy Enhanced Mail) is a representation standard that encodes binary key data in Base64 and wraps it between human-readable header and footer lines (for example, -----BEGIN PRIVATE KEY-----). PEM output is the de-facto standard for OpenSSL-compatible and secure-shell-compatible toolchains. Most transport-layer credentials and identity documents are distributed in this wrapped layout.

PKCS#1 defines RSA-specific key structures — the container carries raw RSA modulus, exponents, and prime factors directly. It has historical compatibility advantages and is the default layout produced by openssl genrsa. PKCS#8 wraps the same RSA key bytes in a general private-key container that also records the method identifier, making it more portable across public-key standards. Modern Java keystores, Python's cipher library, and many cloud key management services prefer PKCS#8.

Additionally, both PKCS#1 and PKCS#8 secret keys can be protected with PEM-level locking using a passphrase. The selected cipher (commonly AES-256) secures the key bytes at rest using a PKCS#5-derived key from your passphrase. This passphrase protection means that even if the container is exposed, an attacker cannot use the secret key without the passphrase. A pem passphrase is strongly recommended for any secret key stored on disk. This layer of data security is a critical part of sound key management.

WARNING: A pem passphrase cannot be recovered. If you forget it, you must generate a replacement key pair and rotate dependent systems. Always keep a protected backup of your passphrase in a vault or hardware keystore.

Generate RSA Keys Locally — OpenSSL, Node.js & Python Implementation Examples

For production use, generate RSA keys locally on a trusted machine using reviewed cipher tooling — not a web interface. Browser generation is excellent for learning and prototyping, but production keys for live services should originate from a secure, air-gapped or hardware-backed environment. The implementation examples below are copy-paste ready and cover the three most common environments.

OpenSSL — Command-Line Key Generation

OpenSSL is the most widely used command-line key tool for server environments. You will need a shell with OpenSSL installed. The following sequence generates a secret key, derives the corresponding shareable key, and then demonstrates how to encrypt data and decrypt a file named input.txt — helping you decrypt file contents using your generated credentials.

# Step 1: Generate a 2048-bit RSA private key (no passphrase)
$ openssl genrsa -out key.pem 2048

# Step 1a: Generate with passphrase protection using AES-256 (recommended for production)
$ openssl genrsa -aes256 -out key.pem 4096

# Step 2: Derive the public key from the secret key file using openssl rsa pubout
$ openssl rsa -in key.pem -pubout -out pubkey.pem

# Step 3: Encrypt input.txt using the shareable key (pubin flag reads a standalone public key)
$ openssl rsautl -encrypt -inkey pubkey.pem -pubin -in input.txt -out input.txt.enc

# Step 4: Decrypt the ciphered file using the inkey flag pointing to the secret key
$ openssl rsautl -decrypt -inkey key.pem -in input.txt.enc -out input.txt

# SSH key pair generation for server login
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa

IMPORTANT: For any key that will protect real data, always use the -aes256 flag with openssl genrsa to enable passphrase protection on your secret key file. Store your shareable key file freely; never commit your secret key to source control. The pubout and pubin flags instruct the OpenSSL commands to read or write a standalone shareable key file rather than embedded key data. The output file input.txt.enc is the ciphered result that only the holder of the secret key can recover — demonstrating decrypted data retrieval via the pasted private key or key file in practice.

Node.js Encryption — Built-In Crypto Module

Node.js ships with the crypto module, making it straightforward to load your PEM files and perform RSA-OAEP ciphering and recovery programmatically. The following example also shows how to generate a fresh key pair and write both key files to disk — a pattern common in microservice bootstrap scripts.

const crypto = require('crypto');
const fs = require('fs');

// Programmatic key pair generation — writes secret key and shareable key files to disk
const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048,           // key length in bits
  publicKeyEncoding:  { type: 'pkcs1', format: 'pem' },
  privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
});
fs.writeFileSync('mykey.pem', privateKey);
fs.writeFileSync('mypubkey.pem', publicKey);

// Load RSA keys from existing PEM files
const loadedPublicKey  = fs.readFileSync('mypubkey.pem',  'utf8');
const loadedPrivateKey = fs.readFileSync('mykey.pem', 'utf8');

// Cipher data using RSA-OAEP with SHA-256
function encryptRSA(data, pubKey) {
  return crypto.publicEncrypt({
    key: pubKey,
    padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
    oaepHash: 'sha256'          // hash selector for the OAEP mask
  }, Buffer.from(data));
}

// Recover ciphered data — only the secret key holder can reverse the operation
function decryptRSA(encryptedData, privKey) {
  return crypto.privateDecrypt({
    key: privKey,
    padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
    oaepHash: 'sha256'
  }, encryptedData);
}

const message   = 'Protect sensitive data with RSA!';
const encrypted = encryptRSA(message, loadedPublicKey);
const decrypted = decryptRSA(encrypted, loadedPrivateKey);
console.log('Decrypted:', decrypted.toString());
// The built-in encrypt and decrypt helpers handle all padding internally

The built-in publicEncrypt and privateDecrypt functions implement the RSA PKCS1 OAEP padding method, which is the modern, secure standard. Using SHA-256 as the hash function ensures the ciphered output is resistant to chosen-ciphertext attacks. This approach provides strong data protection for sensitive payloads, and the decrypted data is returned as a plain Buffer.

Python Digital Signatures — cryptography.hazmat Primitives

Python's cryptography library provides low-level hazmat primitives for RSA key generation, attesting, and validity checking. The example below mirrors the Python digital-signature workflow: generate a secret key with public exponent 65537, sign a message using PSS padding with a mask generation function and SHA-256, then confirm the attestation using the extracted shareable key.

from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa, padding

# Generate secret key — public exponent 65537 is standard; key_size sets the modulus length
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()  # derive shareable key from secret key

# Serialize to PEM — secret key as PKCS#8, shareable key as SubjectPublicKeyInfo
private_pem = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.NoEncryption()
)
public_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)

# Attest data — PSS padding with mask generation function provides approved digital-signature generation
def sign_data(data, private_key):
    return private_key.sign(
        data.encode('utf-8'),
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),  # mask generation function
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()   # PSS padding uses SHA-256 as the digest
    )

# Confirm attestation — proves authenticity and message integrity
def verify_signature(data, signature, public_key):
    try:
        public_key.verify(
            signature,
            data.encode('utf-8'),
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
        return True
    except Exception:
        return False

message   = 'Important document — verify me'
signature = sign_data(message, private_key)
is_valid  = verify_signature(message, signature, public_key)
print(f'Valid signature: {is_valid}')

The PSS (Probabilistic Signature Scheme) with PSS padding and a mask generation function is recommended for new RSA applications. The public_exponent=65537 is the universally accepted standard value — it balances protection and computation cost. This workflow covers key generation, PEM serialization, attesting, and signature verification in a single self-contained script. The compression of key metadata into the PEM container simplifies portability across systems.

IMPORTANT: For production keys, always generate locally using operating system tools or a hardware-backed keystore rather than any online tool. Store secret keys in a dedicated vault, never in source control. Implement key rotation policies and key backup procedures, and restrict access to the minimum required set of processes and users. Following key management best practices — including export controls and import validation — is as important as the key length itself.