Asymmetric Encryption (RSA)

A key pair is generated together. The public key can sit in a file, a certificate, a homepage. The private key is a secret on the same order as a password — worse, because it is long, copyable, and sufficient. Encrypt-to-owner: sender uses the public key; only the private key holder recovers the plaintext. That solves a slice of AES’s distribution problem: Bob publishes a public key; Alice encrypts a random AES key to it; Bob decrypts that wrap; both then AES-encrypt the movie. Mallory can copy the public key and still cannot unwrap the AES key.

Mental model: a padlock anyone can snap shut (public) and only you can open (private). Do not stretch the metaphor into “public means unimportant.” If an attacker swaps Bob’s public key for their own, Alice encrypts to the attacker. That is why PKI exists: binding a name to a public key. This lesson only builds the pair. Treat a raw .pem sitting in a lab folder as a toy, not as “I am the bank.” Anyone can run genrsa. Anyone includes you, a phishing kit, and a well-meaning intern who emailed private.pem to themselves “for backup.”

RSA math on large integers is expensive compared with AES on a stream of blocks. A 2048-bit RSA encryption also has a size cap: you can feed it only a small number of bytes (modulus size minus padding). That is a feature of the design, not a bug to “fix” by splitting a movie into a thousand RSA chunks. The professional pattern is hybrid encryption: RSA (or a modern key-agreement) protects a random AES key; AES-GCM (or similar) protects the payload. TLS does a version of this every time the padlock works. Preview, not a handshake dump — Module 3 walks the TLS dance.

If a tutorial encrypts a whole disk with “only RSA” or claims RSA is obsolete because AES exists, they skipped the hybrid sentence. If a tutorial says beginners should factor a 2048-bit modulus “to understand attacks,” they skipped ethics and arithmetic. Factoring a toy 32-bit demo in a number-theory class is not this course. Attacking a live site’s certificate modulus is not a lab. You will generate, wrap a tiny note, delete. Literacy includes knowing RSA-OAEP and PSS exist as padding; the lab may use openssl’s default encrypt path on a few bytes. Do not homebrew padding. Do not roll a cipher “because RSA felt heavy.”

Key length is not a vibe. 1024-bit RSA is retired for security use. 2048-bit is a common baseline you will still see; 3072 or 4096 appear where policy asks. Newer designs often prefer elliptic curves (smaller keys, similar job). This module teaches RSA because openssl genrsa is visible and the public/private story is the same shape you need for PKI and signatures. Follow current guidance for anything that leaves the lab. A 2048-bit toy key that sat in Downloads for a year is not “hardened.” It is a forgotten secret. Delete it after the decrypt works.

openssl genrsa writes a private key; openssl rsa -pubout extracts the public half. A short-lived unencrypted toy key in cyberlium-lab that you delete is acceptable for this hour. For anything real, protect the private key with a passphrase you do not reuse from email, and with OS ACLs. Never keep a joke bank-prod.pem.

When a browser speaks HTTPS, it does not RSA-encrypt every image tile. It uses asymmetric (or key-agreement) operations to land on session secrets, then AES-GCM or another AEAD for the bytes. Certificates (PKI) tell the browser which public key is allowed to speak for example.com. You now have the three nouns: AES (bulk confidentiality), RSA-class pairs (wrap or sign), PKI (name binding). Module 3 puts them in order as a handshake. Do not skip to “decrypt HTTPS of a site I do not own.” You cannot, and trying is not a homework stretch.

Keep the plaintext tiny — RSA encrypt is for a small blob, which is the teaching point for hybrid wrapping. Do not add a factoring script “to see.” Do not reuse this key on a real server. Git Bash / WSL / macOS / Linux as usual; restrict ACLs on Windows if chmod is missing. After cat shows the note, remove the private key so the lab does not become a forgotten identity.

mkdir -p "$HOME/cyberlium-lab"
cd "$HOME/cyberlium-lab"

openssl genrsa -out toy-rsa-private.pem 2048
openssl rsa -in toy-rsa-private.pem -pubout -out toy-rsa-public.pem

chmod 600 toy-rsa-private.pem toy-rsa-public.pem 2>/dev/null || true

printf 'lab wrap — delete me
' > toy-rsa-note.txt

OpenSSL 3: pkeyutl. (Older docs may show rsautl — same idea, tiny input.)

openssl pkeyutl -encrypt -pubin -inkey toy-rsa-public.pem \
  -in toy-rsa-note.txt -out toy-rsa-note.enc

openssl pkeyutl -decrypt -inkey toy-rsa-private.pem \
  -in toy-rsa-note.enc -out toy-rsa-note.out

cat toy-rsa-note.out

{
  echo "=== RSA LAB NOTES (no private key material) ==="
  echo "public: shareable — encrypt-to-owner or verify signatures"
  echo "private: secret — decrypt or sign; chmod 600; delete toys"
  echo "size: 2048-bit toy; follow current guidance off-lab"
  echo "slow: wrap AES keys / signatures, NOT bulk video"
  echo "hybrid_tls_preview: asymmetric (or KEM) then AES-GCM bulk"
  echo "ethics: MY files; no factoring; no site attacks; delete toy key"
} > rsa-lab-notes.txt
chmod 600 rsa-lab-notes.txt toy-rsa-note.txt 2>/dev/null || true

rm -f toy-rsa-private.pem toy-rsa-note.enc

You now have a pair: public shareable, private secret, 2048-bit toy deleted after a tiny wrap. AES stays the bulk engine; RSA-class math carries keys and, soon, signatures. The remaining lie is “I generated a key, therefore I am the site.” Next — Public Key Infrastructure (PKI) — certificates bind names to public keys, chains walk to a trust anchor, and Module 3 will introduce CAs. Still no breaking RSA. Still $HOME/cyberlium-lab.