RSA best explanation

Encrypting "hello"

Let's encrypt something like "hello" using RSA.

Step 1: Convert "hello" to a number

We use a basic scheme like ASCII:

python

CopyEdit

"hello" → [104, 101, 108, 108, 111]  # ASCII codes

Let's just take the number 104 (which is 'h') to walk through the encryption.

Step 2: Encrypt with public key (e, n)

The encrypted value c is:

python

CopyEdit

c = (m ** e) % n

Where:

m is the plaintext number (e.g. 104)

e and n are from the public key

💡 This works because exponentiation and modulo math are easy to compute in one direction but hard to reverse without the private key.

🔓 Decryption

To decrypt the ciphertext c, you use the private key (d, n):

python

CopyEdit

m = (c ** d) % n

This brings back the original number m (like 104), which you then convert back to a character: 'h'.

🧬 Can you see the pattern between public and private keys?

Yes, kind of.

Both share n

e and d are modular inverses with respect to φ(n)

You cannot see p and q directly from n, unless you factor it (which is very hard if n is 2048-bit+)

So while there's a mathematical relationship, it's computationally infeasible to reverse-engineer d from e and n without factoring n.

🔁 Full Flow Summary

plaintext

CopyEdit

1. Sender encrypts with public key:    c = (m^e) mod n

2. Receiver decrypts with private key: m = (c^d) mod n

🧪 Code Example (Python - Using small primes for demo)

python

CopyEdit

# Super simple demo, not secure primes

p = 61

q = 53

n = p * q                # 3233

phi = (p - 1) * (q - 1)  # 3120

e = 17  # Chosen as public exponent

# Find d such that (d * e) % phi == 1

def modinv(e, phi):

    for d in range(1, phi):

        if (d * e) % phi == 1:

            return d

    return None

d = modinv(e, phi)

# Encrypt a character (say 'h' = 104)

m = 104

c = pow(m, e, n)

print("Encrypted:", c)  # ciphertext

# Decrypt

decrypted = pow(c, d, n)

print("Decrypted:", chr(decrypted))  # back to 'h'

🔐 Why Is RSA So Powerful?

Easy to encrypt with a public key.

Only someone with the private key can decrypt.

Secure even if everyone knows your public key.

Based on hard math (factoring large primes).