ক্রিপ্টোগ্রাফির ভিত্তি — চারটা লক্ষ্য, একটা নীতি

পার্ব ১ — Monoalphabetic substitution: “mapping-টাই secret”। এই cipher-এ প্রতিটা অক্ষরকে আরেকটা অক্ষরে বদলে দেওয়া হয় একটা secret mapping দিয়ে। Attacker-এর কাছে শুধু ciphertext, mapping জানে না।

# obscurity_vs_key.py — obscurity (mapping গোপন) বনাম Kerckhoffs (key গোপন, algorithm public)
import collections, random, string

ENGLISH_FREQ_ORDER = "etaoinshrdlcumwfgypbvkjxqz"

# ---- Part 1: monoalphabetic substitution — সুরক্ষা = "কেউ জানে না mapping কী" ----
random.seed(42)

def make_secret_mapping():
    letters = list(string.ascii_lowercase)
    shuffled = letters[:]
    random.shuffle(shuffled)
    return dict(zip(letters, shuffled))

def substitution_encrypt(plaintext, mapping):
    return "".join(mapping.get(ch, ch) for ch in plaintext)

PLAINTEXT = (
    "the enemy will attack the eastern bridge at dawn the general "
    "has ordered every soldier to hold the line until reinforcements "
    "arrive from the north the situation is critical and every hour "
    "matters to the defenders holding the bridge against the coming assault"
)

mapping = make_secret_mapping()
ciphertext = substitution_encrypt(PLAINTEXT, mapping)

print("ciphertext (attacker-এর কাছে শুধু এইটুকুই আছে, mapping গোপন):")
print(ciphertext)

counts = collections.Counter(c for c in ciphertext if c.isalpha())
cipher_freq_order = "".join(letter for letter, _ in counts.most_common())

print()
print(f"ciphertext letter-freq order (most->least) : {cipher_freq_order}")
print(f"English reference freq order                : {ENGLISH_FREQ_ORDER}")

guess_map = dict(zip(cipher_freq_order, ENGLISH_FREQ_ORDER))
guessed_plain = "".join(guess_map.get(c, c) for c in ciphertext)

print()
print("frequency-analysis guess (key কখনো দেখা যায়নি, শুধু letter-count থেকে):")
print(guessed_plain)

total_letters = sum(1 for p in PLAINTEXT if p.isalpha())
correct = sum(1 for g, p in zip(guessed_plain, PLAINTEXT) if p.isalpha() and g == p)
pct = 100.0 * correct / total_letters
print()
print(f"সঠিকভাবে উদ্ধার হওয়া letter: {correct}/{total_letters} ({pct:.1f}%)")

# ---- Part 2: OTP-style toy — সুরক্ষা = secret key, algorithm সম্পূর্ণ public ----
print()
print("=" * 60)

def xor_bytes(a, b):
    return bytes(x ^ y for x, y in zip(a, b))

def otp_encrypt(key, plaintext_bytes):
    assert len(key) == len(plaintext_bytes)
    return xor_bytes(key, plaintext_bytes)

REAL_MSG = b"ATTACK AT DAWN "
random.seed(7)
REAL_KEY = bytes(random.randrange(256) for _ in range(len(REAL_MSG)))
otp_cipher = otp_encrypt(REAL_KEY, REAL_MSG)

print(f"real plaintext : {REAL_MSG!r}")
print(f"otp ciphertext : {otp_cipher.hex()}")
print()
print("attacker পুরো algorithm জানে (equal-length key দিয়ে byte-wise XOR),")
print("এই ciphertext-ও আছে, কিন্তু REAL_KEY জানে না — চারটা candidate try করে দেখি:")

candidates = [
    b"ATTACK AT DAWN ",
    b"RETREAT AT ONCE",
    b"SEND MORE TROOP",
    b"HOLD THE BRIDGE",
]
for cand in candidates:
    implied_key = xor_bytes(otp_cipher, cand)
    reencrypted = otp_encrypt(implied_key, cand)
    consistent = reencrypted == otp_cipher
    print(f"  candidate={cand!r} -> implied_key={implied_key.hex()} -> consistent={consistent}")

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

ciphertext (attacker-এর কাছে শুধু এইটুকুই আছে, mapping গোপন):
ekt totbd ipss qeeqjl ekt tqyetro mrpzft qe zqio ekt ftotrqs kqy xrztrtz thtrd yxszptr ex kxsz ekt spot voeps rtpogxrjtbtoey qrrpht grxb ekt oxrek ekt ypevqepxo py jrpepjqs qoz thtrd kxvr bqeetry ex ekt ztgtoztry kxszpof ekt mrpzft qfqpoye ekt jxbpof qyyqvse

ciphertext letter-freq order (most->least) : terpqokxyzsfbjvdhgiml
English reference freq order                : etaoinshrdlcumwfgypbvkjxqz

frequency-analysis guess (key কখনো দেখা যায়নি, শুধু letter-count থেকে):
tse eneuf poll ittimv tse eirtean baodce it dipn tse ceneail sir hadeaed egeaf rhldoea th shld tse lone wntol aeonyhameuentr iaaoge yahu tse nhats tse rotwitohn or maotomil ind egeaf shwa uittear th tse deyendear shldonc tse baodce icionrt tse mhuonc irriwlt

সঠিকভাবে উদ্ধার হওয়া letter: 96/216 (44.4%)

============================================================
real plaintext : b'ATTACK AT DAWN '
otp ciphertext : e4199e59667b9b5c3933689f816d5b

attacker পুরো algorithm জানে (equal-length key দিয়ে byte-wise XOR),
এই ciphertext-ও আছে, কিন্তু REAL_KEY জানে না — চারটা candidate try করে দেখি:
  candidate=b'ATTACK AT DAWN ' -> implied_key=a54dca182530bb1d6d132cded6237b -> consistent=True
  candidate=b'RETREAT AT ONCE' -> implied_key=b65cca0b233acf7c786748d0cf2e1e -> consistent=True
  candidate=b'SEND MORE TROOP' -> implied_key=b75cd01d4636d40e7c133ccdce220b -> consistent=True
  candidate=b'HOLD THE BRIDGE' -> implied_key=ac56d21d462fd31919713ad6c52a1e -> consistent=True

দুইটা ফলাফল পাশাপাশি রাখুন। পার্ট ১-এ attacker key কখনো দেখেইনি — শুধু ciphertext-এর letter-count গুনে, তাকে English-এর স্বাভাবিক letter- frequency-র সাথে মিলিয়ে, কোনো “cryptanalysis” ছাড়াই ৯৬/২১৬ মানে ৪৪.৪% অক্ষর সরাসরি সঠিক বসিয়ে ফেলেছে — আর বাকি অংশও এতটাই কাছাকাছি (tse = “the”, eneuf = “enemy”) যে বাকি সংশোধন একটা মানুষের চোখেই কয়েক মিনিটের কাজ। Mapping “গোপন” ছিল ঠিকই, কিন্তু গোপনীয়তাটা কোনো বাস্তব সুরক্ষা দেয়নি — কারণ cipher-এর নকশাটাই structure ফাঁস করে (প্রতিটা plaintext-অক্ষর সবসময় একই ciphertext-অক্ষরে যায়, তাই frequency shape অবিকৃত থেকে যায়)।

পার্ট ২-এ ঠিক উল্টো: attacker-কে পুরো algorithm দিয়েই দেওয়া হয়েছে (byte-wise XOR, equal-length key — এক বাক্যে বর্ণনাযোগ্য, কোনো গোপন কৌশল নেই), তার কাছে real ciphertext-ও আছে। তবু চারটা সম্পূর্ণ ভিন্ন candidate plaintext-ই (ATTACK AT DAWN, RETREAT AT ONCE, SEND MORE TROOP, HOLD THE BRIDGE) একেকটা আলাদা implied_key-র সাথে সেই একই ciphertext তৈরি করে — মানে ciphertext একা দেখে বলার কোনো উপায় নেই কোনটা আসল বার্তা। প্রতিটা candidate-ই সমান সম্ভাব্য, যতক্ষণ না real key জানা যাচ্ছে। এটাই One-Time-Pad- এর বিখ্যাত perfect secrecy ধর্ম, Shannon ১৯৪৯-এ যা প্রমাণ করেছিলেন — algorithm সম্পূর্ণ প্রকাশ্য থাকা সত্ত্বেও।