Digital Signature ও PKI — সই তো হলো, কিন্তু কার সই?

লক্ষ্য: শুধু “chain of trust কাজ করে” বলাই না, একটা browser-এর মতোই পাঁচটা ধাপ কোডে বাস্তবায়ন করে দেখানো — আর তারপর একটা বাস্তবসম্মত আক্রমণ (leaf-এ নিজের key বসিয়ে দেওয়া, পুরনো signature সহ) চালিয়ে দেখানো ঠিক কোন ধাপে সেটা ধরা পড়ে।

# toy_pki.py — root CA -> intermediate CA -> leaf certificate, আর একটা toy
# "browser" যেটা ঠিক একই ভাবে chain-টা হাঁটে যেভাবে বাস্তব TLS client হাঁটে
import random, hashlib, math

random.seed(20260827)

def is_prime(n, rounds=25):
    if n < 2:
        return False
    for p in (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37):
        if n % p == 0:
            return n == p
    d, r = n - 1, 0
    while d % 2 == 0:
        d //= 2
        r += 1
    for _ in range(rounds):
        a = random.randrange(2, n - 1)
        x = pow(a, d, n)
        if x in (1, n - 1):
            continue
        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    return True

def gen_prime(bits):
    while True:
        cand = random.getrandbits(bits) | (1 << (bits - 1)) | 1
        if is_prime(cand):
            return cand

def gen_keypair(bits=96):
    p, q = gen_prime(bits), gen_prime(bits)
    while p == q:
        q = gen_prime(bits)
    n = p * q
    phi = (p - 1) * (q - 1)
    e = 65537
    while math.gcd(e, phi) != 1:
        e += 2
    d = pow(e, -1, phi)
    return (n, e), (n, d)

def h_int(data: bytes) -> int:
    return int(hashlib.sha256(data).hexdigest(), 16)

def sign_bytes(data: bytes, priv):
    n, d = priv
    return pow(h_int(data), d, n)

def verify_bytes(data: bytes, signature: int, pub) -> bool:
    n, e = pub
    return pow(signature, e, n) == h_int(data) % n

# ---------- একটা certificate: কার, কার দ্বারা ইস্যু, কোন public key, কতদিন ----------
def tbs(subject, issuer, pub_n, valid_from, valid_to):
    # "to-be-signed" body — ঠিক যা X.509 বলে TBSCertificate
    return f"subject={subject}|issuer={issuer}|pubkey_n={pub_n}|valid={valid_from}..{valid_to}".encode()

def issue_cert(subject, issuer, subject_pub, issuer_priv, valid_from, valid_to):
    body = tbs(subject, issuer, subject_pub[0], valid_from, valid_to)
    sig = sign_bytes(body, issuer_priv)
    return {"subject": subject, "issuer": issuer, "pub": subject_pub,
            "valid_from": valid_from, "valid_to": valid_to, "sig": sig}

def cert_verifies_against(cert, issuer_pub) -> bool:
    body = tbs(cert["subject"], cert["issuer"], cert["pub"][0], cert["valid_from"], cert["valid_to"])
    return verify_bytes(body, cert["sig"], issuer_pub)

# ---------- chain বানানো: root (self-signed) -> intermediate -> leaf ----------
root_pub, root_priv = gen_keypair()
inter_pub, inter_priv = gen_keypair()
leaf_pub, leaf_priv = gen_keypair()

root_cert = issue_cert("Root CA", "Root CA", root_pub, root_priv, 2026, 2046)              # self-signed
inter_cert = issue_cert("Intermediate CA", "Root CA", inter_pub, root_priv, 2026, 2036)    # signed BY root
leaf_cert = issue_cert("example.com", "Intermediate CA", leaf_pub, inter_priv, 2026, 2027) # signed BY intermediate

TRUST_STORE = {"Root CA": root_pub}   # যা OS/browser আগে থেকেই pre-installed রাখে

def browser_validate_chain(leaf, inter, root, trust_store):
    print(f"  [1] root cert subject == issuer (self-signed)?  {root['subject'] == root['issuer']}")
    root_known = root["subject"] in trust_store and trust_store[root["subject"]] == root["pub"]
    print(f"  [2] root public key present in trust store?      {root_known}")
    root_ok = cert_verifies_against(root, root["pub"])
    print(f"  [3] root cert signature self-verifies?           {root_ok}")
    inter_ok = cert_verifies_against(inter, root["pub"])
    print(f"  [4] intermediate cert verifies with ROOT's pub?   {inter_ok}")
    leaf_ok = cert_verifies_against(leaf, inter["pub"])
    print(f"  [5] leaf cert verifies with INTERMEDIATE's pub?   {leaf_ok}")
    return root_known and root_ok and inter_ok and leaf_ok

print("=== legitimate chain: example.com <- Intermediate CA <- Root CA ===")
ok = browser_validate_chain(leaf_cert, inter_cert, root_cert, TRUST_STORE)
print(f"  => chain trusted, bind pubkey to 'example.com': {ok}")

print()
print("=== attack: swap the leaf cert's public key, KEEP the old signature ===")
mallory_pub, mallory_priv = gen_keypair()
forged_leaf = dict(leaf_cert)
forged_leaf["pub"] = mallory_pub          # attacker-এর নিজের key, example.com-এর আসল key-র বদলে
# forged_leaf["sig"] অপরিবর্তিত রইল — attacker-এর কাছে Intermediate CA-র private key
# ছাড়া নতুন বৈধ signature বানানোর কোনো উপায় নেই
ok2 = browser_validate_chain(forged_leaf, inter_cert, root_cert, TRUST_STORE)
print(f"  => chain trusted, bind pubkey to 'example.com': {ok2}")

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

=== legitimate chain: example.com <- Intermediate CA <- Root CA ===
  [1] root cert subject == issuer (self-signed)?  True
  [2] root public key present in trust store?      True
  [3] root cert signature self-verifies?           True
  [4] intermediate cert verifies with ROOT's pub?   True
  [5] leaf cert verifies with INTERMEDIATE's pub?   True
  => chain trusted, bind pubkey to 'example.com': True

=== attack: swap the leaf cert's public key, KEEP the old signature ===
  [1] root cert subject == issuer (self-signed)?  True
  [2] root public key present in trust store?      True
  [3] root cert signature self-verifies?           True
  [4] intermediate cert verifies with ROOT's pub?   True
  [5] leaf cert verifies with INTERMEDIATE's pub?   False
  => chain trusted, bind pubkey to 'example.com': False

লক্ষ্য করুন ঠিক কোথায় attack ধরা পড়ল — ধাপ ১ থেকে ৪ পর্যন্ত সব সবুজ, কারণ attacker root বা intermediate কিছুই ছোঁয়নি। শুধু ধাপ ৫-এ, leaf-এর নিজস্ব check-এ, ধরা পড়ল — কারণ forged_leaf["pub"] বদলানোর সাথে সাথে tbs(...)-এর bytes বদলে গেছে (pubkey_n field-টাই তো ওই bytes-এর অংশ), তাই H(tbs) বদলেছে, কিন্তু signature পুরনোই রয়ে গেছে — সেই পুরনো signature নতুন hash-এর সাথে মেলে না। Attacker-এর কাছে একমাত্র উপায় ছিল Intermediate CA-র private key দিয়ে নতুন করে সাইন করা — যা তার কাছে কখনোই ছিল না।

নিজে বাড়ান:

1. leaf_cert["valid_to"]-কে অতীতের একটা বছরে বদলে দিন (validity বদলাননি signature বদলায়নি) — cert_verifies_against কি তাও পাস করবে? কেন validity-check আলাদা করে করতে হয়, শুধু signature verify যথেষ্ট না কেন, ব্যাখ্যা করুন।
2. একটা চতুর্থ স্তর যোগ করুন — একটা দ্বিতীয় intermediate, প্রথম intermediate-এর দ্বারা সাইন করা (“sub-intermediate”)। browser_validate_chain কীভাবে বদলাতে হবে একটা arbitrary-length chain হ্যান্ডল করতে?
3. TRUST_STORE-এ যদি ভুলবশত mallory_pub-ও ঢুকিয়ে দেওয়া হয় (একটা malicious root trusted হয়ে গেছে), legitimate chain validation-এ তার কী প্রভাব পড়বে? এখান থেকেই বোঝা যায় root CA compromise কেন এত বিধ্বংসী।