Symmetric Encryption ও Block Cipher Mode — একই চাবি, দুই কাজ

ECB — কেন “সহজতম” mode-টাই ভাঙা

Electronic Codebook (ECB) সবচেয়ে naive approach: plaintext-কে ব্লকে কাটো, প্রতিটা ব্লক স্বাধীনভাবে E(key, block_i) চালাও, ফলাফল পাশাপাশি বসাও। কোনো chaining নেই, কোনো IV নেই। সমস্যাটা এক লাইনে:

block_i == block_j  ⟹  E(key, block_i) == E(key, block_j)

Cipher যতই শক্তিশালী হোক — deterministic function হওয়ার কারণে একই input সবসময় একই output দেয়। Plaintext-এ যদি পুনরাবৃত্তি থাকে (কোনো ছবির flat background, কোনো ফাইলের header pattern, ডাটাবেসের একই default-value কলাম), সেই পুনরাবৃত্তি ciphertext-এও হুবহু থেকে যায় — নিচের experiment-এ এটা সংখ্যায় দেখাব।

CBC — IV আর chaining দিয়ে পুনরাবৃত্তি ঢাকা

Cipher Block Chaining (CBC) সমাধান করে একটা সহজ trick দিয়ে: প্রতিটা plaintext block encrypt করার আগে আগের ব্লকের ciphertext-এর সাথে XOR করে নেওয়া হয়। প্রথম ব্লকের জন্য “আগের ব্লক” নেই — তাই একটা random Initialization Vector (IV) ব্যবহার হয়:

c_0 = E(key, p_0 XOR IV)
c_i = E(key, p_i XOR c_{i-1})     i >= 1

এখন দুইটা identical plaintext block-ও ভিন্ন ciphertext দেয়, কারণ তাদের “আগের ciphertext” আলাদা (যদি না পুরো prefix-ই identical হয়)। কিন্তু দুইটা শর্ত ভাঙলে বিপদ:

IV-র জন্য দ্বিতীয় শর্ত: unpredictable হতে হবে (শুধু unique নয়) — নইলে chosen-plaintext attack-এ attacker আগে থেকেই XOR-এর ফলাফল আন্দাজ করতে পারে (TLS-এর BEAST attack, ২০১১, এই দুর্বলতাই কাজে লাগিয়েছিল)।

CTR — block cipher থেকে stream cipher

Counter mode (CTR) সম্পূর্ণ আলাদা কৌশল নেয়: plaintext সরাসরি encrypt না করে, cipher দিয়ে একটা keystream বানানো হয় — nonce আর একটা বাড়তে-থাকা counter মিলিয়ে প্রতিটা block-এর জন্য E(key, nonce || counter_i) চালিয়ে; তারপর সেই keystream শুধু plaintext-এর সাথে XOR হয়:

keystream_i = E(key, nonce || i)
c_i = p_i XOR keystream_i

তিনটা সুবিধা সরাসরি এই সংজ্ঞা থেকে আসে: (১) parallelizable — প্রতিটা keystream_i স্বাধীনভাবে গণনা করা যায়, block chain-এর জন্য অপেক্ষা লাগে না; (২) no padding — XOR যেকোনো length-এ কাজ করে, শেষ ব্লক ছোট হলেও সমস্যা নেই; (৩) decrypt = encrypt, একই keystream আবার XOR করলেই plaintext ফেরত। কিন্তু এই সরলতার দাম একটাই কড়া নিয়মে: keystream কখনো দুইবার ব্যবহার করা যাবে না — নিচে দেখুন কেন।

GCM — CTR + built-in authentication

Galois/Counter Mode (GCM) হলো CTR-এর ওপর একটা authentication layer বসানো সংস্করণ — encryption আর authentication এক পাসেই হয়ে যায় বলে একে বলা হয় AEAD (Authenticated Encryption with Associated Data)। GCM ভেতরে CTR-mode দিয়েই encrypt করে, সাথে সাথে GHASH নামের একটা Galois-field function দিয়ে একটা authentication tag গণনা করে। Output: ciphertext + tag। Decrypt-এর সময় tag verify আগে, plaintext ব্যবহার পরে — tag না মিললে পুরো output বাতিল, একটা byte-ও touch করা হয় না।

“Associated Data” অংশটা গুরুত্বপূর্ণ: TLS-এর packet header, HTTP-এর কিছু metadata — এগুলো এনক্রিপ্ট করার দরকার নেই (plaintext-ই থাকবে), কিন্তু tamper করা যাবে না। GCM-কে সেই extra ডেটা (AAD হিসেবে) দিলে সেটাও tag-এর হিসাবে ঢুকে যায় — encrypt না করেও authenticate করা যায়।

Nonce-reuse বিপর্যয় — এক XOR-এই সব শেষ

CTR আর GCM দুটোই keystream E(key, nonce || counter)-এর ওপর নির্ভর করে। যদি একই (key, nonce) জোড়া দুইবার ব্যবহার হয় — দুইটা ভিন্ন message-এর জন্য — তাহলে দুইটা ক্ষেত্রেই হুবহু একই keystream তৈরি হয়। আর তখন সহজ বীজগণিত:

c1 = p1 XOR ks         c2 = p2 XOR ks
c1 XOR c2 = (p1 XOR ks) XOR (p2 XOR ks) = p1 XOR p2     (ks বাতিল!)

Attacker key জানে না, তবু c1 XOR c2 গণনা করেই সরাসরি p1 XOR p2 পেয়ে যায় — keystream সম্পূর্ণ কেটে যায়। আর যদি attacker p1-এর কিছু অংশ জানে বা আন্দাজ করতে পারে (যেমন প্রায়-সব API request-এর একই fixed header), সেই অংশ XOR করে p2-র সেই একই অংশ বেরিয়ে আসে — আর common-prefix-বাদে বাকিটাও frequency- analysis দিয়ে ভাঙা যায়। নিচের কোডটা আসলেই চালানো, hand-wave নয়:

# nonce_reuse.py — CTR-স্টাইল keystream reuse বিপর্যয় (AES-এর জায়গায় toy stand-in)
import hashlib

def keystream_block(key, nonce, counter):
    # AES(key, nonce||counter)-এর ভূমিকা এখানে একটা keyed hash খেলছে
    return hashlib.sha256(key + nonce + counter.to_bytes(4, "big")).digest()

def ctr_keystream(key, nonce, nbytes):
    out, counter = b"", 0
    while len(out) < nbytes:
        out += keystream_block(key, nonce, counter)
        counter += 1
    return out[:nbytes]

def ctr_encrypt(key, nonce, plaintext):
    ks = ctr_keystream(key, nonce, len(plaintext))
    return bytes(p ^ k for p, k in zip(plaintext, ks))

def xor_bytes(a, b):
    n = min(len(a), len(b))
    return bytes(a[i] ^ b[i] for i in range(n))

key = b"aes-256-key-goes-right-here!!!!"
nonce = b"\x00\x00\x00\x00\x00\x00\x00\x00"     # একই nonce দুইবার — এখানেই bug

msg1 = b"To: bank-api  Amount: $100.00  To-Acct: alice-0091"
msg2 = b"To: bank-api  Amount: $9999.99 To-Acct: mallory-77"

c1 = ctr_encrypt(key, nonce, msg1)
c2 = ctr_encrypt(key, nonce, msg2)

xor_c = xor_bytes(c1, c2)
xor_p = xor_bytes(msg1, msg2)
print(f"c1 XOR c2 == m1 XOR m2 : {xor_c == xor_p}")

recovered = xor_bytes(xor_c, msg1)   # attacker msg1 জানে (fixed header)
print(f"recovered m2 = (c1 XOR c2) XOR m1 -> {recovered.decode()!r}")
print(f"recovered m2 == real m2 : {recovered == msg2}")

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

c1 XOR c2 == m1 XOR m2 : True
recovered m2 = (c1 XOR c2) XOR m1 -> 'To: bank-api  Amount: $9999.99 To-Acct: mallory-77'
recovered m2 == real m2 : True

লক্ষ্য করুন: msg1 (attacker-এর জানা “known plaintext”) আর c1 XOR c2 দিয়েই msg2 পুরোপুরি উদ্ধার হয়ে গেছে — key ভাঙা লাগেনি, brute-force লাগেনি। শুধু একটা XOR। এই একই গণিত ২০১৬ সালের বাস্তব nonce-reuse incident-গুলোর ভিত্তি — কিছু TLS implementation-এ IV generation-এর bug থাকায় GCM nonce পুনরাবৃত্তি হয়েছিল, আর forgery/decryption বাস্তবে demonstrate করা গিয়েছিল।