Asymmetric Cryptography — Diffie-Hellman ও RSA, চাবি ছাড়াই চাবি বিনিময়

লক্ষ্য: RSA আর AES-স্টাইল symmetric cipher-কে একসাথে ব্যবহার করা — প্রতিটা নিজের সবচেয়ে ভালো কাজে। RSA স্লো, আর একটা নির্দিষ্ট maximum message-size-এ সীমাবদ্ধ (modulus n-এর বিট-সংখ্যার নিচে); symmetric cipher দ্রুত এবং যেকোনো length-এ কাজ করে। বাস্তব TLS, PGP, S/MIME — সবাই এই একই প্যাটার্ন অনুসরণ করে।

# hybrid.py — Hybrid encryption: toy RSA শুধু session key wrap করতে, bulk data-তে toy symmetric cipher
import hashlib
from math import gcd

def extended_gcd(a, b):
    if a == 0:
        return b, 0, 1
    g, x1, y1 = extended_gcd(b % a, a)
    return g, y1 - (b // a) * x1, x1

def modinv(e, phi):
    g, x, _ = extended_gcd(e, phi)
    assert g == 1
    return x % phi

# ---------- Bob-এর toy RSA keypair (আগের অংশের মতোই ছোট, শুধু demo-র জন্য) ----------
p, q = 61, 53                      # আগের চেয়ে বড় যাতে session-key-এর জায়গা থাকে n-এ
n = p * q
phi = (p - 1) * (q - 1)
e = 17
d = modinv(e, phi)
print(f"Bob-এর public key  (n, e) = ({n}, {e})")
print(f"Bob-এর private key (n, d) = ({n}, {d})  -- গোপন")

# ---------- ধাপ ১: Alice একটা random session key বানায় (n-এর চেয়ে ছোট হতে হবে RSA-wrap-এর জন্য) ----------
import random
random.seed(42)
session_key_int = random.randrange(1000, n)   # toy: বাস্তবে os.urandom(32)-ধাঁচ, তারপর n-এর নিচে map করা লাগত
print(f"\nAlice-এর random session key (সংখ্যা হিসেবে) = {session_key_int}")

# ---------- ধাপ ২: Alice এই session key-টাই RSA দিয়ে wrap করে, পুরো payload না ----------
wrapped_key = pow(session_key_int, e, n)     # শুধু session key encrypt হচ্ছে, payload না
print(f"RSA-wrapped session key = {wrapped_key}   (এটাই channel দিয়ে পাঠানো হয়)")

# ---------- ধাপ ৩: Bob নিজের private key দিয়ে session key ফেরত পায় ----------
recovered_key_int = pow(wrapped_key, d, n)
print(f"Bob RSA-unwrap করে ফেরত পেল session key = {recovered_key_int}")
print(f"session key মিলল: {recovered_key_int == session_key_int}")

# ---------- ধাপ ৪: session key দিয়ে toy symmetric (CTR-স্টাইল keystream) দিয়ে bulk payload encrypt ----------
def derive_sym_key(key_int):
    return hashlib.sha256(str(key_int).encode()).digest()

def keystream_block(key, counter):
    return hashlib.sha256(key + counter.to_bytes(4, "big")).digest()

def ctr_crypt(key, data):
    counter = 0
    ks = b""
    while len(ks) < len(data):
        ks += keystream_block(key, counter)
        counter += 1
    return bytes(a ^ b for a, b in zip(data, ks))

sym_key = derive_sym_key(session_key_int)
payload = ("Subject: Q3 report\n"
           "এই পুরো ইমেইলটা bulk payload — কয়েক KB, কয়েক MB হতে পারে। "
           "RSA দিয়ে সরাসরি এটা encrypt করা বাস্তবসম্মত না, "
           "কিন্তু AES-এর মতো symmetric cipher-এর জন্য এটা তুচ্ছ কাজ।").encode("utf-8")
print(f"\nbulk payload length = {len(payload)} bytes")

ciphertext = ctr_crypt(sym_key, payload)
decrypted = ctr_crypt(sym_key, ciphertext)   # CTR: encrypt আর decrypt একই অপারেশন
print(f"ciphertext (প্রথম ৩২ byte hex) = {ciphertext[:32].hex()}")
print(f"decrypt সফল (round-trip): {decrypted == payload}")

# ---------- কেন সরাসরি RSA-তে পুরো payload যায় না, দেখানো ----------
print("\n--- কেন RSA সরাসরি bulk payload-এ ব্যবহার হয় না ---")
oversized_block = int.from_bytes(payload[:64], "big")
print(f"payload-এর প্রথম অংশকে সংখ্যা বানালে (৬৪ byte) = একটা বিশাল integer,")
print(f"যার bit-length = {oversized_block.bit_length()} বিট, কিন্তু n-এর bit-length মাত্র {n.bit_length()} বিট।")
print(f"m >= n হলে RSA-এর mod n reduction তথ্য হারিয়ে ফেলে (m mod n != m) —")
print(f"তাই RSA-block-size (n-এর বিট-সংখ্যা) থেকে বড় কোনো ডেটা সরাসরি এক-ধাপে RSA-encrypt করা যায় না।")
print(f"এই জন্যই RSA শুধু session-key wrap-এ ব্যবহার হয় — key সবসময় n-এর চেয়ে ছোট রাখা যায়,")
print(f"bulk payload যত বড়ই হোক, session key-র সাইজ স্থির থাকে।")

প্রত্যাশিত output (deterministic — fixed seed, হুবহু এটাই আসবে):

Bob-এর public key  (n, e) = (3233, 17)
Bob-এর private key (n, d) = (3233, 2753)  -- গোপন

Alice-এর random session key (সংখ্যা হিসেবে) = 1456
RSA-wrapped session key = 2900   (এটাই channel দিয়ে পাঠানো হয়)
Bob RSA-unwrap করে ফেরত পেল session key = 1456
session key মিলল: True

bulk payload length = 367 bytes
ciphertext (প্রথম ৩২ byte hex) = 98652308d778027bf9d7c9e1e77ae72587094cc5737f9734c788adc355eb1012
decrypt সফল (round-trip): True

--- কেন RSA সরাসরি bulk payload-এ ব্যবহার হয় না ---
payload-এর প্রথম অংশকে সংখ্যা বানালে (৬৪ byte) = একটা বিশাল integer,
যার bit-length = 511 বিট, কিন্তু n-এর bit-length মাত্র 12 বিট।
m >= n হলে RSA-এর mod n reduction তথ্য হারিয়ে ফেলে (m mod n != m) —
তাই RSA-block-size (n-এর বিট-সংখ্যা) থেকে বড় কোনো ডেটা সরাসরি এক-ধাপে RSA-encrypt করা যায় না।
এই জন্যই RSA শুধু session-key wrap-এ ব্যবহার হয় — key সবসময় n-এর চেয়ে ছোট রাখা যায়,
bulk payload যত বড়ই হোক, session key-র সাইজ স্থির থাকে।

মূল মুহূর্ত দুইটা জায়গায়: প্রথম, session key মিলল: True — Bob কখনো session_key_int channel দিয়ে দেখেনি, শুধু wrapped_key দেখেছে, তবু নিজের private key দিয়ে হুবহু ফেরত পেয়েছে। দ্বিতীয়, bit-length তুলনা — 367 byte-এর payload-এর একটা ছোট অংশও (64 byte) 511-বিটের সংখ্যা হয়ে যায়, যেখানে toy RSA-এর n মাত্র 12-বিট — বাস্তব ২০৪৮-বিট RSA-তেও এই অনুপাত একই থিমে থাকে: RSA modulus একটা fixed-size সীমা, payload তা সহজেই ছাড়িয়ে যায়। এই জন্যই hybrid approach — RSA শুধু session key wrap করে, key-র সাইজ সবসময় modulus-এর নিচে রাখা যায়, payload যতই বড় হোক সমস্যা হয় না।

নিজে বাড়ান:

1. session_key_int যদি n-এর চেয়ে বড় বা সমান হয়ে যায়, কী ঘটবে দেখুন — কেন এটা একটা silent bug হতে পারে, আর বাস্তব library এটা কীভাবে এড়ায় (হিন্ট: key সবসময় fixed, ছোট byte-length-এ generate করা হয়)
2. RSA encrypt-এর গতি বনাম CTR-cipher-এর গতি তুলনা করুন — %timeit বা time.perf_counter() দিয়ে একই payload-এর জন্য দুইটা approach-এর সময় মাপুন (RSA সরাসরি byte-by-byte encrypt করলে কল্পনা করুন)
3. Diffie-Hellman দিয়ে একই hybrid pattern রিরাইট করুন — RSA-wrap-এর বদলে DH shared-secret থেকে সরাসরি session key derive করুন; কোন পার্থক্যটা লক্ষ্যণীয় (হিন্ট: RSA-তে Alice key বানায় ও পাঠায়, DH-এ দুইজনেই স্বাধীনভাবে derive করে)