RSA Key Generation - Problem

Implement a simplified RSA key generation, encryption, and decryption system. RSA is a public-key cryptosystem that uses the mathematical properties of large prime numbers.

Your task:

Generate two distinct prime numbers p and q within a given range
Calculate n = p × q (the modulus)
Calculate φ(n) = (p-1) × (q-1) (Euler's totient function)
Find a public exponent e such that 1 < e < φ(n) and gcd(e, φ(n)) = 1
Calculate the private exponent d such that (d × e) mod φ(n) = 1
Encrypt a given message using the public key (e, n)
Decrypt the encrypted message using the private key (d, n)

Return an object containing the generated keys and the encryption/decryption results.

Input & Output

Example 1 — Basic RSA with Small Primes

$ Input: minPrime = 10, maxPrime = 20, message = 42

› Output: {"p":11,"q":13,"n":143,"phi_n":120,"e":7,"d":103,"encrypted":123,"decrypted":42}

💡 Note: Found primes p=11, q=13. Calculated n=143, φ(n)=120. Used e=7, found d=103. Encrypted 42 to 123, decrypted back to 42.

Example 2 — Larger Prime Range

$ Input: minPrime = 5, maxPrime = 15, message = 25

› Output: {"p":5,"q":7,"n":35,"phi_n":24,"e":5,"d":5,"encrypted":15,"decrypted":25}

💡 Note: Found primes p=5, q=7. With n=35 and φ(n)=24, e=5 works and d=5. Message 25 encrypts to 15, decrypts back to 25.

Example 3 — Single Digit Message

$ Input: minPrime = 3, maxPrime = 10, message = 2

› Output: {"p":3,"q":5,"n":15,"phi_n":8,"e":3,"d":3,"encrypted":8,"decrypted":2}

💡 Note: Small primes p=3, q=5 give n=15, φ(n)=8. Using e=3 and d=3, message 2 encrypts to 8 and decrypts correctly.

Constraints

2 ≤ minPrime ≤ maxPrime ≤ 100
1 ≤ message < n (where n is the product of chosen primes)
Range must contain at least 2 prime numbers

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 42 f Meta 30 🍎 Apple 25

The key insight is using the mathematical properties of prime numbers and modular arithmetic. RSA security relies on the fact that multiplying primes is easy but factoring their product is computationally hard. The optimal approach uses Sieve of Eratosthenes for efficient prime generation and Extended Euclidean Algorithm for fast modular inverse calculation. Time: O(n log log n), Space: O(n)

Common Approaches

✓ Brute Force Prime Generation

⏱️ Time: O(n³) Space: O(1)

Find primes by testing every number in range for divisibility by all smaller numbers. Use trial division for GCD and modular inverse calculations.

Sieve + Extended Euclidean Algorithm

⏱️ Time: O(n log log n) Space: O(n)

Generate primes efficiently using sieve, calculate GCD and modular inverse using Extended Euclidean Algorithm, and use fast modular exponentiation.

Brute Force Prime Generation — Algorithm Steps

Check every number in range for primality by testing all divisors
Find public exponent e by testing each number for GCD with φ(n)
Calculate private exponent d by testing all values until (d×e) mod φ(n) = 1
Perform encryption/decryption with repeated multiplication

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Primes

Test each number by checking all potential divisors

Calculate Keys

Use trial division to find GCD and modular inverse

Encrypt/Decrypt

Perform modular exponentiation with repeated multiplication

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

int isPrime(int n) {
    if (n < 2) return 0;
    for (int i = 2; i <= sqrt(n); i++) {
        if (n % i == 0) return 0;
    }
    return 1;
}

int gcd(int a, int b) {
    while (b) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

int modInverse(int e, int phi) {
    for (int d = 1; d < phi; d++) {
        if ((d * e) % phi == 1) {
            return d;
        }
    }
    return -1;
}

int modPow(int base, int exp, int mod) {
    int result = 1;
    for (int i = 0; i < exp; i++) {
        result = (result * base) % mod;
    }
    return result;
}

void solution(int minPrime, int maxPrime, int message) {
    int primes[2];
    int primeCount = 0;
    
    for (int num = minPrime; num <= maxPrime && primeCount < 2; num++) {
        if (isPrime(num)) {
            primes[primeCount++] = num;
        }
    }
    
    if (primeCount < 2) {
        printf("{\"error\":-1}\n");
        return;
    }
    
    int p = primes[0], q = primes[1];
    int n = p * q;
    int phi_n = (p - 1) * (q - 1);
    
    int e = 3;
    while (e < phi_n) {
        if (gcd(e, phi_n) == 1) break;
        e += 2;
    }
    
    int d = modInverse(e, phi_n);
    
    int encrypted = modPow(message, e, n);
    int decrypted = modPow(encrypted, d, n);
    
    printf("{\"p\":%d,\"q\":%d,\"n\":%d,\"phi_n\":%d,\"e\":%d,\"d\":%d,\"encrypted\":%d,\"decrypted\":%d}\n",
           p, q, n, phi_n, e, d, encrypted, decrypted);
}

int main() {
    int minPrime, maxPrime, message;
    scanf("%d", &minPrime);
    scanf("%d", &maxPrime);
    scanf("%d", &message);
    
    solution(minPrime, maxPrime, message);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Primality testing O(n√n), GCD calculation O(n), modular inverse O(φ(n))

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing a few variables, no extra data structures

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

RSA Key Generation - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Prime Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler