RSA Key Generator

About RSA Key Generator

This RSA key generator creates 2048-bit RSA-OAEP key pairs entirely in your browser using the Web Crypto API (crypto.subtle). RSA is an asymmetric cryptographic algorithm widely used for secure data transmission, digital signatures, and key exchange protocols.

RSA Algorithm Overview

RSA (Rivest-Shamir-Adleman) was invented in 1977 and remains one of the most widely used public-key cryptosystems:

RSA Key Generation:

1. Choose two large prime numbers p and q
   (For 2048-bit key, each prime is ~1024 bits)

2. Compute modulus n = p × q
   n is the public modulus used in both keys

3. Compute Euler's totient: φ(n) = (p-1)(q-1)

4. Choose public exponent e
   Common choice: e = 65537 (0x10001)
   Must be coprime to φ(n)

5. Compute private exponent d
   d = e^(-1) mod φ(n)
   (modular multiplicative inverse)

6. Public key: (n, e)
   Private key: (n, d)

Encryption: c = m^e mod n
Decryption: m = c^d mod n

Web Crypto API Implementation

JavaScript RSA Key Generation:

async function generateRSAKeyPair() {
  const keyPair = await crypto.subtle.generateKey(
    {
      name: "RSA-OAEP",
      modulusLength: 2048,
      publicExponent: new Uint8Array([1, 0, 1]), // 65537
      hash: "SHA-256"
    },
    true, // extractable
    ["encrypt", "decrypt"]
  );

  // Export public key (SPKI format)
  const pubKey = await crypto.subtle.exportKey("spki", keyPair.publicKey);
  const pubKeyBase64 = arrayBufferToBase64(pubKey);

  // Export private key (PKCS#8 format)
  const privKey = await crypto.subtle.exportKey("pkcs8", keyPair.privateKey);
  const privKeyBase64 = arrayBufferToBase64(privKey);

  return { pubKeyBase64, privKeyBase64 };
}

// RSA-OAEP Encryption
async function rsaEncrypt(publicKey, plaintext) {
  const encoder = new TextEncoder();
  const data = encoder.encode(plaintext);

  const ciphertext = await crypto.subtle.encrypt(
    { name: "RSA-OAEP" },
    publicKey,
    data
  );

  return arrayBufferToBase64(ciphertext);
}

// RSA-OAEP Decryption
async function rsaDecrypt(privateKey, ciphertextBase64) {
  const ciphertext = base64ToArrayBuffer(ciphertextBase64);

  const plaintext = await crypto.subtle.decrypt(
    { name: "RSA-OAEP" },
    privateKey,
    ciphertext
  );

  const decoder = new TextDecoder();
  return decoder.decode(plaintext);
}

RSA Key Size Comparison

Padding Schemes Comparison

Key Format Specifications

Public Key Format (SPKI - Subject Public Key Info):
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2Z3qX2BTLS4e...
(base64 encoded DER of ASN.1 structure)
-----END PUBLIC KEY-----

Private Key Format (PKCS#8):
-----BEGIN PRIVATE KEY-----
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDZne...
(base64 encoded DER of ASN.1 structure)
-----END PRIVATE KEY-----

RSA Private Key (PKCS#1 - alternative format):
-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEA2Z3qX2BTLS4e...
(contains p, q, d, dp, dq, qInv for CRT optimization)
-----END RSA PRIVATE KEY-----

Hybrid Encryption

Due to RSA's size limitations, real-world systems use hybrid encryption:

Hybrid Encryption Flow:

1. Generate random symmetric key (AES-256)
   const aesKey = await crypto.subtle.generateKey(
     { name: "AES-GCM", length: 256 },
     true, ["encrypt", "decrypt"]
   );

2. Encrypt data with AES key
   const encryptedData = await crypto.subtle.encrypt(
     { name: "AES-GCM", iv: randomIV },
     aesKey,
     plaintext
   );

3. Encrypt AES key with RSA public key
   const encryptedKey = await crypto.subtle.encrypt(
     { name: "RSA-OAEP" },
     rsaPublicKey,
     exportedAesKey
   );

4. Send: encryptedData + encryptedKey + IV
   Recipient decrypts AES key with RSA private key,
   then decrypts data with AES key.

This approach combines RSA's secure key exchange
with AES's efficient bulk encryption.

RSA Security Considerations

Common Use Cases

• Key Exchange: Securely exchange symmetric keys for AES encryption
• Digital Signatures: Sign and verify documents using RSA-PSS or RSA-PKCS#1 v1.5
• TLS/SSL: Establish secure connections (though being replaced by ECC)
• SSH Keys: Authenticate to remote servers
• PGP/GPG: Encrypt emails and files
• JWT Signing: Sign JSON Web Tokens with RS256 algorithm
• Code Signing: Sign software for distribution
• Certificate Generation: Create X.509 certificates

Limitations

• Message size limit: ~190 bytes for 2048-bit RSA-OAEP
• Slow for large data: Much slower than symmetric encryption
• Quantum vulnerable: Shor's algorithm can break RSA on quantum computers
• Key size: Large keys compared to ECC (256-bit ECC ≈ 3072-bit RSA)
• No forward secrecy: If private key is compromised, all past messages can be decrypted

Post-Quantum Considerations

RSA is vulnerable to quantum computers using Shor's algorithm. For long-term security:

• Hybrid schemes: Combine RSA with post-quantum algorithms (Kyber, NTRU)
• ECC migration: Elliptic Curve Cryptography offers smaller keys but also quantum-vulnerable
• NIST PQC: NIST is standardizing post-quantum algorithms (CRYSTALS-Kyber selected)
• Timeline: Large-scale quantum computers estimated 10-30 years away