Symmetric encryption — AES, mode, nonce আর authenticated encryption

১ · এক চাবির তালা — symmetric encryption কী দেয়, কী দেয় না

বাড়ির দরজার তালা ভাবুন। যে চাবিতে তালা লাগান, সেই চাবিতেই খোলেন। পরিবারের প্রত্যেকের কাছে একটি করে কপি থাকে। Symmetric encryption-এর ধারণা ঠিক এটুকুই: পাঠানোর দিক আর পাওয়ার দিক একই গোপন চাবি জানে। Plaintext (মূল লেখা) আর চাবি মিলে তৈরি হয় ciphertext (তালাবন্ধ লেখা), আর একই চাবি দিয়ে ciphertext থেকে মূল লেখা ফেরে।

পর্ব ০৭-এ (Cryptography-র ভিত্তি) গোপনীয়তা, অখণ্ডতা আর পরিচয়ের পার্থক্য দেখা হয়েছে, আর Kerckhoffs-এর নীতি মনে করিয়ে দিয়েছে যে গোপন থাকবে শুধু চাবি। পর্ব ০২-এর (CIA triad) ভাষায় encryption মূলত confidentiality রক্ষা করে। Integrity বা availability রক্ষা করে না, যদি না আপনি আলাদা ব্যবস্থা নেন। এই একটি বাক্য মনে রাখলে এই পর্বের অর্ধেক ভুল এড়ানো যায়।

Symmetric cipher সাধারণত public key পদ্ধতির চেয়ে অনেক দ্রুত, তাই বড় ফাইল, disk, ডেটাবেস আর network ট্রাফিক এভাবেই এনক্রিপ্ট হয়। এর বড় দুর্বলতা হলো দুই পক্ষের কাছে চাবি পৌঁছানো। সেই সমস্যার সমাধান দেখবেন পর্ব ১০-এ (Public key cryptography).

Block cipher আর stream cipher

সীমারেখা বাস্তবে ঝাপসা। পরে দেখবেন CTR mode একটি block cipher-কে stream cipher বানিয়ে ফেলে। তাই “block না stream” যতটা নকশার প্রশ্ন, “কোন mode আর কোন nonce নিয়ম” ততটাই নিরাপত্তার প্রশ্ন।

২ · DES থেকে AES — কেন পুরোনো cipher অবসরে গেল

DES-এর সমস্যা দুটি, আর দুটিই সংখ্যার। প্রথমত, ২^৫৬ ≈ ৭.২ × ১০^১৬টি চাবি একসময় অসম্ভব মনে হলেও যন্ত্র সস্তা হতেই নাগালে চলে আসে। তাই একে বলা হয় brute force-এর সীমা। দ্বিতীয়ত, ৬৪ bit block ছোট। প্রায় ২^৩২টি block, অর্থাৎ 32 GiB ডেটা এক চাবিতে গেলে দুটি ciphertext block মিলে যাওয়ার সম্ভাবনা গুরুতর হয়ে ওঠে। ২০১৬ সালের Sweet32 গবেষণা দেখায় লম্বা সংযোগে এই সীমা বাস্তব ঝুঁকি।

১৯৯৭ সালে NIST একটি প্রকাশ্য প্রতিযোগিতা শুরু করে। নকশা, আক্রমণের চেষ্টা, সবই ছিল খোলা। ২০০০ সালে বেলজিয়ামের Joan Daemen আর Vincent Rijmen-এর Rijndael নির্বাচিত হয়, আর ২০০১ সালে সেটি AES নামে FIPS 197 হিসেবে প্রকাশিত হয়। এটি open design নীতির সবচেয়ে ভালো উদাহরণগুলোর একটি।

খেয়াল করুন, চাবি বড় হলেও block একই থাকে। Round মানে একই ধরনের কাজের একটি পালা। ১৯৪৯ সালে Claude Shannon দুটি গুণ চেয়েছিলেন: confusion (চাবি আর আউটপুটের সম্পর্ক জটিল করা) আর diffusion (একটি বাইটের প্রভাব সব দিকে ছড়ানো)। AES-এর চারটি কাজ এই দুটিই করে। রান্নার মতো ভাবুন: মসলা বদলানো, হাঁড়ির উপাদান সরানো, নেড়ে মেশানো, আর গোপন উপাদান যোগ করা, এভাবে বারবার।

নিচের stepper-এ FIPS 197-এর Appendix B-র আসল মান দেখুন। AES ১৬টি বাইটকে ৪ × ৪ ছকে সাজায়, যার নাম state. বাইটগুলো কলাম ধরে বসে।

input        key
32 88 31 e0  2b 28 ab 09
43 5a 31 37  7e ae f7 cf
f6 30 98 07  15 d2 15 4f
a8 8d a2 34  16 a6 88 3c

19 a0 9a e9
3d f4 c6 f8
e3 e2 8d 48
be 2b 2a 08

d4 e0 b8 1e
27 bf b4 41
11 98 5d 52
ae f1 e5 30

d4 e0 b8 1e   সারি ০: নড়েনি
bf b4 41 27   সারি ১: ১ ঘর বাঁয়ে
5d 52 11 98   সারি ২: ২ ঘর
30 ae f1 e5   সারি ৩: ৩ ঘর

04 e0 48 28
66 cb f8 06
81 19 d3 26
e5 9a 7a 4c

a4 68 6b 02
9c 9f 5b 6a
7f 35 ea 50
f2 2b 43 49

মানগুলো আমরা নিজের scratch script-এ হিসাব করে Appendix B-র সাথে মিলিয়েছি। AES-এর চার কাজ আপনাকে হাতে করতে হবে না, আর কখনো নিজে লিখবেনও না। জানা দরকার একটি কারণে: AES একটি মাত্র ১৬ বাইটের block নিয়ে কাজ করে। ১৬ বাইটের বেশি ডেটা হলে কী করবেন, প্রায় সব ভুল সেখানেই শুরু হয়।

৩ · Mode — একটি block থেকে পুরো বার্তা

Mode of operation হলো সেই নিয়ম, যা বলে দেয় block cipher দিয়ে লম্বা বার্তা কীভাবে এনক্রিপ্ট হবে। NIST SP 800-38A (২০০১) ECB, CBC, CFB, OFB আর CTR বর্ণনা করে, আর SP 800-38D (২০০৭) GCM. নিচের ছবিতে তিনটি mode-এর গঠন দেখুন।

ECB — কোড-বইয়ের ফাঁদ

ECB-তে প্রতিটি block আলাদাভাবে এনক্রিপ্ট হয়। ধরুন একটি পুরোনো কোড-বইয়ে “টাকা” লিখলেই সবসময় “আম” লেখা হয়। কেউ অর্থ না জানলেও দেখবে কোন শব্দ কতবার ফিরে আসছে। ECB ঠিক তাই করে: একই plaintext block মানেই একই ciphertext block. চাবি ভাঙেনি, তবু নকশা ফাঁস হয়ে গেছে।

CBC — আগের ciphertext-এর সাথে শিকল

CBC-তে প্রতিটি plaintext block আগের ciphertext block-এর সাথে XOR হয়ে তবেই AES-এ যায়। প্রথম block-এর আগে কিছু নেই, তাই লাগে IV (initialization vector). CBC-র IV গোপন নয়, ciphertext-এর সাথেই যায়, কিন্তু হতে হবে আগে থেকে অনুমান করা যায় না এমন। অনুমানযোগ্য IV থেকেই TLS 1.0-র CBC-তে ২০১১ সালে BEAST সমস্যা দেখা দেয়। CBC-তে বার্তাকে block-এর মাপে পূরণ করতে padding লাগে, আর সেখান থেকে আরেক ধরনের ফাঁদ আসে (অংশ ৫)।

CTR — block cipher থেকে stream

CTR-এ AES দিয়ে plaintext এনক্রিপ্ট করাই হয় না। এনক্রিপ্ট হয় nonce‖0, nonce‖1, nonce‖2 এমন একটি গণনা, আর তার ফল হয় keystream. সেই keystream plaintext-এর সাথে XOR হয়। সুবিধা অনেক: padding লাগে না, block-গুলো সমান্তরালে চলে, যেকোনো জায়গা থেকে পড়া যায়। মূল্য একটি কঠিন শর্ত: একই চাবিতে একই (nonce, counter) জোড়া কখনো ফিরতে পারবে না।

এবার হাতে হিসাব করা যায় এমন একটি খেলনা cipher দিয়ে তিনটি mode পাশাপাশি দেখুন। দুটি plaintext block ইচ্ছা করেই একই রাখা হয়েছে।

E(x) = ((x XOR 2b) * 5 + 7) mod 256
P1 = 41, P2 = 41 (hex), IV = 3c
CTR: nonce = a, counter = 0, 1

এবার একটি ছোট ছবিতে পার্থক্যটি চোখে দেখুন। প্রতিটি pixel একটি ৮-bit block, চিহ্নগুলো ciphertext বাইটের প্রতিনিধি।

// Toy 8-bit block cipher: real নয়, শুধু ধারণার জন্য. Real: AES-GCM.
function mulberry32(a) {
  return () => { a = a + 0x6D2B79F5 | 0; let t = Math.imul(a ^ a >>> 15, 1 | a);
    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; return ((t ^ t >>> 14) >>> 0) / 4294967296; };
}
const rnd = mulberry32(2026);              // the "key" picks one shuffle of 0..255
const E = [...Array(256).keys()];
for (let i = 255; i > 0; i--) {
  const j = Math.floor(rnd() * (i + 1)); [E[i], E[j]] = [E[j], E[i]];
}
const SYM = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const sym = b => SYM[b % 64];
const img = ["..........", "...####...", "..#....#..", "..#....#..", "...####...", ".........."];
const NONCE = 0x20;
let ctr = 0;
const ecbSeen = new Set(), ctrSeen = new Set();
console.log("plain       ECB         CTR");
for (const row of img) {
  let e = "", c = "";
  for (const ch of row) {
    const p = ch.charCodeAt(0);
    const eb = E[p], cb = p ^ E[(NONCE + ctr++) & 255];
    ecbSeen.add(eb); ctrSeen.add(cb);
    e += sym(eb); c += sym(cb);
  }
  console.log(row + "  " + e + "  " + c);
}
console.log("distinct bytes: ECB =", ecbSeen.size, ", CTR =", ctrSeen.size);

..#....#..  yykyyyykyy  fUidTjcmBJ
distinct bytes: ECB = 2 , CTR = 57

৪ · IV, nonce আর পুনর্ব্যবহারের সর্বনাশ

Nonce মানে “number used once”, একবারই ব্যবহৃত সংখ্যা। অফিসের রেজিস্টার খাতার ক্রমিক নম্বরের মতো: গোপন নয়, কিন্তু একই নম্বর দুবার বসলে খাতার হিসাব ভেঙে পড়ে। IV-ও একই পরিবারের, তবে শব্দ দুটির দাবি আলাদা।

শব্দের ব্যবহার সব জায়গায় সমান নয়। NIST GCM-এর nonce-কেও “IV” বলে, আর অনেক library-র parameter-এর নাম iv. তাই নাম নয়, mode-এর শর্ত দেখে বিচার করুন।

কেন এত বিপদ — ছোট উদাহরণে

আগের stepper-এর keystream ছিল be. ধরুন ভুল করে একই চাবি আর একই nonce দিয়ে দুটি আলাদা বার্তার প্রথম বাইট এনক্রিপ্ট হলো: P = 41 আর Q = 4d. তাহলে C1 = 41 ⊕ be = ff, আর C2 = 4d ⊕ be = f3. পথের একজন পর্যবেক্ষক শুধু দুটি ciphertext দেখেন। তিনি XOR করলে পান ff ⊕ f3 = 0c, যা হুবহু 41 ⊕ 4d = 0c. চাবি কিছুই জানতে হলো না:

Keystream কেটে গেল। Plaintext-এর গঠন যেহেতু এলোমেলো নয়, দুই plaintext-এর XOR থেকে অনেক তথ্য বের হতে পারে, আর একটি বার্তা জানা থাকলে অন্যটি সরাসরি মিলে যায়। এটি one-time pad-এর একই পাতা দুবার ব্যবহারের ভুল। নিচের খেলনা কোডে ভুলটি দেখুন, সাথে দেখুন রক্ষক কীভাবে log থেকে এটি ধরতে পারেন।

// Toy stream cipher: real নয়, শুধু ধারণার জন্য. A warning about misuse.
function stream(key, nonce, n) {
  let a = (key ^ Math.imul(nonce, 0x9E3779B1)) | 0;
  const out = [];
  for (let i = 0; i < n; i++) {
    a = a + 0x6D2B79F5 | 0; let t = Math.imul(a ^ a >>> 15, 1 | a);
    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; out.push((t ^ t >>> 14) & 255);
  }
  return out;
}
const bytes = s => [...s].map(c => c.charCodeAt(0));
const hex = a => a.map(b => b.toString(16).padStart(2, "0")).join("");
const xor = (a, b) => a.map((x, i) => x ^ b[i]);
const KEY = 0x2b7e1516;
const p1 = bytes("PAY 500 TK RINA"), p2 = bytes("MEET 9 PM GATE3");
const c1 = xor(p1, stream(KEY, 7, 15));
const c2 = xor(p2, stream(KEY, 7, 15));   // MISUSE: nonce 7 again
const c3 = xor(p2, stream(KEY, 8, 15));   // correct: fresh nonce
const leak = xor(c1, c2), goal = xor(p1, p2);
console.log("c1 xor c2 :", hex(leak));
console.log("p1 xor p2 :", hex(goal));
console.log("same nonce leaks p1^p2:", hex(leak) === hex(goal));
console.log("fresh nonce leaks p1^p2:", hex(xor(c1, c3)) === hex(goal));
// Defender: spot a repeated (key, nonce) pair in an in-memory log.
const log = [["k1", 7], ["k1", 8], ["k1", 7], ["k2", 7]];
const seen = new Set();
for (const [k, n] of log) {
  const id = k + ":" + n;
  console.log(id, seen.has(id) ? "REUSE: stop and rotate key" : "ok");
  seen.add(id);
}

c1 xor c2 : 1d041c7415091070196b67131d0b72
p1 xor p2 : 1d041c7415091070196b67131d0b72
same nonce leaks p1^p2: true
fresh nonce leaks p1^p2: false
k1:7 REUSE: stop and rotate key

৫ · Encryption একা অখণ্ডতা দেয় না — AEAD কেন

অনেকে ভাবেন, “এনক্রিপ্ট করা আছে, কেউ বদলাতে পারবে না।” এটি সবচেয়ে ব্যয়বহুল ভুল ধারণাগুলোর একটি। তালাবন্ধ বাক্স কেউ খুলতে না পারলেও বাক্সের গায়ে আঘাত করতে পারে, আর ভেতরের জিনিসের জায়গা বদলে যেতে পারে। CTR আর stream cipher-এ ciphertext-এর একটি bit উল্টালে plaintext-এর ঠিক সেই bit উল্টে যায়। এই গুণের নাম malleability. প্রাপক কিছুই টের পান না, কারণ decrypt সবসময় “কিছু একটা” ফেরত দেয়।

নিচের খেলনা কোডে ciphertext সরাসরি বদলানো হয়েছে, চাবি ছাড়াই। দেখুন authentication tag না থাকলে কী হয়, আর থাকলে কী হয়। এখানে keystream খেলনা, কিন্তু HMAC আর constant-time তুলনা Python-এর আসল library.

# Toy keystream with a real HMAC tag: real নয়, শুধু ধারণার জন্য
import hashlib, hmac

ENC_KEY = b"example-enc-key"          # fake demo keys, two separate keys
MAC_KEY = b"example-mac-key"
NONCE = b"n-0001"

def keystream(n):
    out, ctr = b"", 0
    while len(out) < n:
        out += hashlib.sha256(ENC_KEY + NONCE + bytes([ctr])).digest()
        ctr += 1
    return out[:n]

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

def seal(msg):                        # encrypt first, then MAC the ciphertext
    ct = xor(msg, keystream(len(msg)))
    return ct, hmac.new(MAC_KEY, NONCE + ct, hashlib.sha256).digest()

def open_box(ct, tag):                # check the tag BEFORE decrypting
    want = hmac.new(MAC_KEY, NONCE + ct, hashlib.sha256).digest()
    if not hmac.compare_digest(want, tag):
        return None
    return xor(ct, keystream(len(ct)))

ct, tag = seal(b"PAY 500 TK")
bad = bytearray(ct)
bad[4] ^= ord("5") ^ ord("9")         # changed in transit, no key used
bad = bytes(bad)
print("no check  :", xor(bad, keystream(len(bad))))
print("with check:", open_box(bad, tag))
print("untouched :", open_box(ct, tag))

no check  : b'PAY 900 TK'
with check: None
untouched : b'PAY 500 TK'

তিন ক্রম, একটি নিরাপদ অভ্যাস

Encryption আর MAC একসাথে দেওয়ার তিনটি পুরোনো পথ আছে। পোস্ট অফিসের খামে সিলমোহরের কথা ভাবুন: সিল কি চিঠির গায়ে, না বন্ধ খামের ওপর?

২০০০ সালে Bellare আর Namprempre এই ক্রমগুলোর নিরাপত্তা তাত্ত্বিকভাবে তুলনা করেন। তবু বাস্তবে নিজে জোড়া দেওয়া ঝুঁকিপূর্ণ: আলাদা চাবি লাগে, nonce-কেও MAC-এ রাখতে হয়, তুলনা constant-time হতে হয়। CBC-তে যাচাই ছাড়া padding ত্রুটি দেখালে padding oracle নামের সমস্যা দেখা দেয়: ত্রুটির বার্তা নিজেই গোপন তথ্যের ইঙ্গিত দেয়। Vaudenay ২০০২ সালে এটি বর্ণনা করেন, আর পরে TLS-এর CBC-তে নানা রূপে ফিরে আসে। তাই সমাধান এলো একসাথে বাঁধা এক প্যাকেজে।

AEAD — এক কাজে গোপনীয়তা আর অখণ্ডতা

AEAD (Authenticated Encryption with Associated Data) একটিমাত্র interface: ইনপুট চাবি, nonce, plaintext আর associated data. আউটপুট ciphertext আর tag. RFC 5116 (২০০৮) এই interface-কে মান হিসেবে বর্ণনা করে।

Associated data (AD) হলো যে অংশ এনক্রিপ্ট হবে না, কিন্তু বদলানোও যাবে না। মোবাইল ব্যাংকিংয়ের লেনদেনের কথা ভাবুন: লেনদেনের নোট গোপন, কিন্তু রাউটিংয়ের জন্য লেনদেন নম্বর খোলা থাকতে হয়। সেই নম্বর কেউ বদলালে যেন ধরা পড়ে। Packet header, ডেটাবেসের row id, চাবির version, সবই ভালো AD.

৬ · AES-GCM আর ChaCha20-Poly1305

AES-GCM হলো CTR mode-এর encryption আর GHASH নামের একটি দ্রুত গাণিতিক হিসাব। সাধারণ রূপে nonce ৯৬ bit, tag ১২৮ bit. চাবি থেকে একটি গোপন মান H তৈরি হয় (H = E(K, 0)). GHASH সেই H দিয়ে AD আর ciphertext থেকে একটি মান বানায়, আর শেষে nonce-নির্ভর একটি গোপন মুখোশ XOR হয়ে tag হয়।

নিচের মানগুলো আমরা নিজের scratch folder-এ Node.js-এর crypto দিয়ে আসল AES-128-GCM চালিয়ে পেয়েছি। চাবিটি শুধু দেখানোর জন্য, কোথাও ব্যবহারের নয়।

key   000102030405060708090a0b0c0d0e0f
nonce a0a1a2a3a4a5a6a7a8a9aaab
AD    order=1042
P     PAY 500 TK

P   5041592035303020544b
KS  aa8638bb7e89330a8a78
C   fac7619b4bb9032ade33

GHASH(H, AD, C) ⊕ E(K, nonce-block)
T = d3e38fe517eb11e6
    401244abd98d4fdf

nonce a0a1a2a3a4a5a6a7a8a9aaab
AD    order=1042
C     fac7619b4bb9032ade33
T     d3e38fe517eb11e6
      401244abd98d4fdf

tag recomputed == T
OK: PAY 500 TK

C  fac7619b43b9032ade33
FAIL: Unsupported state or
unable to authenticate data
plaintext দেওয়া হয়নি

AD order=1043
FAIL: Unsupported state or
unable to authenticate data
nonce-এর শেষ bit বদলালেও FAIL

ChaCha20-Poly1305

RFC 8439 (২০১৮) এই AEAD-কে বর্ণনা করে। ChaCha20 হলো Daniel J. Bernstein-এর stream cipher, যা শুধু যোগ, ঘোরানো আর XOR দিয়ে চলে; Poly1305 tag বানায়। চাবি ২৫৬ bit, nonce ৯৬ bit, tag ১২৮ bit. এখানেও একই চাবিতে nonce ফেরানো যাবে না। পার্থক্য আসে হার্ডওয়্যারে।

সিদ্ধান্তের নিয়মটি সহজ। সার্ভার আর আধুনিক ল্যাপটপে AES-GCM সাধারণত ভালো। AES নির্দেশ নেই এমন যন্ত্রে, বা যেখানে software-এ constant-time চাই, ChaCha20-Poly1305 ভালো। দুটোই নিরাপদ পছন্দ, দুটোরই nonce শর্ত একই।

৭ · Nonce বানানোর নীতি — birthday সীমা আর রক্ষকের পরিকল্পনা

Nonce বানানোর দুই পথ: ক্রমিক counter, অথবা CSPRNG থেকে random সংখ্যা। Random সহজ, state রাখতে হয় না। কিন্তু random হলেই পুনরাবৃত্তি অসম্ভব নয়। প্রশ্ন হলো কতগুলো বার্তার পরে ঝুঁকি মানা যায় না।

Birthday হিসাব

একটি ক্লাসে মাত্র ২৩ জন থাকলেই দুজনের জন্মদিন মিলে যাওয়ার সম্ভাবনা ৫০%-এর বেশি। কারণ আমরা নির্দিষ্ট একজনের সাথে মিল খুঁজছি না, যেকোনো জোড়ার মিল খুঁজছি, আর জোড়ার সংখ্যা দ্রুত বাড়ে। একে বলে birthday bound. nটি বার্তা হলে জোড়া n(n−1)/2টি, আর b-bit nonce-এ প্রতিটি জোড়া মেলার সম্ভাবনা 2^−b. তাই ছোট p-র জন্য:

পুরো হিসাব, b = 96: n = 2³² হলে p ≈ 2⁶⁴ ÷ 2⁹⁷ = 2⁻³³ ≈ ১.১৬ × ১০^−১০. প্রায় ৮৬০ কোটিতে একবার। NIST SP 800-38D-এর শর্ত হলো এক চাবিতে random IV-র সংঘর্ষের সম্ভাবনা ২^−৩২-এর নিচে থাকবে, আর তাই সেখানে সীমা ২^৩২ বার encryption. সেকেন্ডে ১ লাখ বার্তায় এই সীমা আসে প্রায় ১২ ঘণ্টায়। সংখ্যাটি বড় শোনালেও ব্যস্ত সার্ভিসে সহজেই পৌঁছায়।

// Birthday-bound calculator for random nonces (pure arithmetic).
const pAny = (n, bits) => -Math.expm1(-n * (n - 1) / 2 / 2 ** bits);
console.log("messages   p, 96-bit random nonce");
for (const e of [20, 28, 32, 36, 40, 44, 48]) {
  console.log(("2^" + e).padEnd(10), pAny(2 ** e, 96).toExponential(2));
}
const half = Math.sqrt(2 * Math.LN2 * 2 ** 96);
console.log("50% near n =", half.toExponential(2));
console.log("n for p = 2^-32: 2^" + Math.log2(Math.sqrt(2 * 2 ** -32 * 2 ** 96)).toFixed(1));
console.log("1e9 messages: p =", pAny(1e9, 96).toExponential(2));
console.log("64-bit nonce, 2^32 messages: p =", pAny(2 ** 32, 64).toFixed(3));
console.log("192-bit nonce, 2^64 messages: p =", (2 ** 128 / 2 ** 193).toExponential(2));
for (const r of [1e3, 1e5, 1e6]) {
  const hours = 2 ** 32 / r / 3600;
  console.log(r.toExponential(0) + " msg/s reaches 2^32 in", hours.toFixed(1), "hours");
}

2^32       1.16e-10
2^44       1.95e-3
2^48       3.93e-1
50% near n = 3.31e+14
n for p = 2^-32: 2^32.5
64-bit nonce, 2^32 messages: p = 0.393
192-bit nonce, 2^64 messages: p = 2.71e-20
1e+5 msg/s reaches 2^32 in 11.9 hours

কোন পথ কখন

এবার পরিস্থিতিটি রক্ষকের চোখে দেখুন। কাল্পনিক invoice-api সার্ভিস GCM-এ counter nonce ব্যবহার করে। Log-এর মান fake, চাবি log-এ নেই, শুধু key_id আর nonce.

10:00:01 key=k7 nonce=...0041 rec=A
10:00:02 key=k7 nonce=...0042 rec=B
10:00:03 key=k7 nonce=...0043 rec=C

10:05:00 VM restored from snapshot
snapshot-এ counter ছিল ...0041 এর আগে

10:05:03 key=k7 nonce=...0041 rec=D
10:05:04 key=k7 nonce=...0042 rec=E
decrypt আগের মতোই সফল

group by (key_id, nonce)
alert if count > 1
ALERT k7 ...0041 count=2 (A, D)
ALERT k7 ...0042 count=2 (B, E)

confidentiality: A+D, B+E at risk
integrity: treat ALL k7 data as
           forgeable (GCM)
severity: high

k7: encrypt = OFF, decrypt only
k8: new key, new nonce space
re-encrypt stored k7 records
destroy k7 after migration

reserve counter blocks in durable store
or: per-boot key from KMS
keep alert: (key_id, nonce) count > 1
add alert: key_id encrypt count limit

৮ · বাস্তব সিদ্ধান্ত — চাবির আকার, মান আর library

চাবির আকার কত

NIST SP 800-57 Part 1 Rev. 5 (২০২০) AES-128-কে ১২৮ bit নিরাপত্তা শক্তির হিসেবে ধরে, আর সেই শক্তি ২০৩১ সালের পরেও গ্রহণযোগ্য বলে তালিকাভুক্ত। NIST-এর post-quantum প্রশ্নোত্তরে বলা হয়েছে, Grover-এর algorithm AES-এ সামান্যই সুবিধা দেবে বলে মনে হয়, আর ১২৮, ১৯২, ২৫৬ তিন আকারই ব্যবহার করা চলে। তবে কিছু নিয়ন্ত্রিত পরিবেশ AES-256 চায়, যেমন যুক্তরাষ্ট্রের CNSA 2.0. তাই পরামর্শটি শর্তসাপেক্ষ:

• সাধারণ কাজে: AES-128-GCM বা AES-256-GCM, দুটোই শক্ত। দীর্ঘমেয়াদি ডেটা বা নিয়মের শর্ত থাকলে AES-256 বেছে নেওয়া যুক্তিসঙ্গত।
• Tag: ১২৮ bit রাখুন। ছোট tag-এ জালিয়াতি সহজ হয়; NIST ২০২৪ সালে জানিয়েছে, GCM-এর সংশোধনে ৯৬ bit-এর চেয়ে ছোট tag বাদ যাবে।
• চাবি: CSPRNG থেকে, password থেকে সরাসরি নয়। Password থেকে চাবি বানাতে আলাদা ধীর পদ্ধতি লাগে (পর্ব ১৩, Password নিরাপদে রাখা)।
• এক চাবির আয়ু: গণনা রাখুন, সীমার আগে ঘোরান (key rotation). Cloud-এ চাবি সামলানো দেখুন Secrets আর KMS পর্বে।

নিজে লিখবেন না — library বাছাই

AES-এর সূত্র ঠিকঠাক লিখলেও বাস্তবায়ন নিরাপদ নাও হতে পারে। সময়ের পার্থক্য, cache-এর আচরণ, ত্রুটির বার্তা, সবই তথ্য ফাঁস করতে পারে। তাই নিয়ম: নিজের cipher, নিজের mode, নিজের AES, কোনোটিই উৎপাদনে নয়। বাছাইয়ে দেখুন:

• সক্রিয়ভাবে রক্ষণাবেক্ষণ হচ্ছে, নিরাপত্তা আপডেট আসে
• সহজ interface: AEAD ডিফল্ট, ভুল করার সুযোগ কম
• Nonce নিজে বানায়, অথবা স্পষ্ট লেখে কে দায়িত্ব নেবে
• Tag ব্যর্থ হলে plaintext দেয় না, ত্রুটি দেয়
• নিয়মের শর্ত থাকলে প্রয়োজনীয় প্রত্যয়ন (যেমন FIPS 140) আছে

উদাহরণ হিসেবে libsodium, Tink, Python-এর cryptography, ভাষার নিজস্ব standard library বা OS-এর crypto API আছে; কোনোটিই একমাত্র উত্তর নয়। নিচে Python cryptography-র AEAD ব্যবহারের ধরন দেখুন। এটি উদাহরণ, পাতায় চলে না, কারণ runner-এ ওই package নেই।

# উদাহরণ: AEAD API-র ধরন (নিজের প্রকল্পে, cryptography package লাগবে)
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.exceptions import InvalidTag

key = AESGCM.generate_key(bit_length=256)   # real system: load from a KMS
aead = AESGCM(key)

nonce = os.urandom(12)                      # never repeat under this key
ad = b"table=orders;row=1042;key=v3"
ct = aead.encrypt(nonce, b"example-message", ad)   # ct ends with the 16-byte tag

try:
    pt = aead.decrypt(nonce, ct, ad)        # returns only if the tag matches
except InvalidTag:
    pt = None                               # reject, log, show a generic error

৯ · AI-এর যুগে — সুন্দর কোড, ভুল crypto

AI encryption কোড দ্রুত লিখে দেয়, আর সেটি চলেও। সমস্যা হলো ভুল crypto-ও চলে: decrypt সফল, test সবুজ, অথচ নিরাপত্তা নেই। তাই এখানে “চলছে” কোনো প্রমাণ নয়।

AI-এর crypto কোড যাচাইয়ের চেকলিস্ট

• Mode AEAD: AES-GCM বা ChaCha20-Poly1305, নিজের জোড়া দেওয়া নয়
• একই plaintext দুবার encrypt করলে ciphertext আলাদা আসে
• Ciphertext, AD আর tag-এ এক bit বদলালে open ব্যর্থ হয়, test-এ প্রমাণিত
• Nonce-এর উৎস আর সীমা লেখা আছে, চাবি-প্রতি গণনা রাখা হয়
• চাবি কোডে নেই, prompt-এ কখনো পেস্ট হয়নি
• AI-এর উল্লেখ করা standard মূল উৎসে নিজে পড়েছি