Cryptography-র ভিত্তি — symmetric, public key, hash আর signature

১ · Cryptography কী চায় — চার লক্ষ্য আর তাদের হাতিয়ার

ধরুন রাজশাহী থেকে আপনি ঢাকার এক বন্ধুকে কুরিয়ারে একটি চিঠি পাঠাচ্ছেন। পথে চিঠিটি অনেক হাত ঘোরে — কাউন্টারের কর্মী, ট্রাকের চালক, বাছাই-কেন্দ্র। ইন্টারনেটে আপনার প্রতিটি packet-এর অবস্থাও ঠিক তাই: বাসার Wi-Fi router, ISP-র যন্ত্র, IXP, সমুদ্রের নিচের তার, অন্য দেশের router — যে কেউ চাইলে পড়তে, বদলাতে বা জাল চিঠি ঢোকাতে পারে। পর্ব ৪৬-এ (নেটওয়ার্ক নিরাপত্তার ভিত্তি) দেখেছেন হুমকিগুলো কী কী। এই পর্বে দেখব সেই হুমকির বিরুদ্ধে গণিতের হাতিয়ার — cryptography.

প্রথমে চারটি আলাদা প্রশ্ন আলাদা করে চেনা দরকার, কারণ প্রতিটির হাতিয়ার আলাদা:

পর্ব ০৯-এ (Error detection) দেখেছেন, CRC আর checksum দুর্ঘটনাজনিত ভুল ধরে, কিন্তু ইচ্ছাকৃত বদল ঠেকায় না — আক্রমণকারী ডেটা বদলে নতুন CRC বসিয়ে দিতে পারে, কারণ CRC হিসাব করতে কোনো গোপন কিছু লাগে না। Cryptography-র সাথে এখানেই পার্থক্য: এর নিরাপত্তা দাঁড়িয়ে থাকে একটি গোপন চাবির ওপর, বা এমন গাণিতিক সমস্যার ওপর যা সমাধান করতে মহাবিশ্বের বয়সের চেয়ে বেশি সময় লাগে।

২ · One-time pad আর brute force — নিখুঁত গোপনীয়তার দাম

একটি cipher-এর তিনটি অংশ: plaintext (মূল লেখা), চাবি, আর ciphertext (তালাবন্ধ লেখা)। সবচেয়ে সরল আর সবচেয়ে শক্তিশালী cipher-টি দাঁড়িয়ে আছে XOR-এর ওপর — যে কাজটি পর্ব ০৯-এ CRC-তে দেখেছেন। XOR-এর জাদু: (P ⊕ K) ⊕ K = P. একই চাবি দুবার XOR করলে আগের জিনিস ফেরত আসে।

One-time pad-এ চাবি হয় বার্তার সমান লম্বা, সম্পূর্ণ এলোমেলো, আর মাত্র একবার ব্যবহৃত। ১৯৪৯ সালে Claude Shannon প্রমাণ করেন এটি নিখুঁতভাবে গোপন (perfect secrecy): ciphertext C দেখে প্রতিটি সম্ভাব্য plaintext সমান সম্ভাব্য থাকে, কারণ যেকোনো P'-এর জন্য একটি চাবি K' = C ⊕ P' আছে যা ঠিক ওই ciphertext দেয়। অসীম কম্পিউটার শক্তি দিয়েও কিছু শেখা যায় না।

তাহলে সবাই এটি ব্যবহার করে না কেন? তিনটি কারণে। (১) চাবি বার্তার সমান লম্বা — ১ GB ভিডিও পাঠাতে আগে থেকে ১ GB গোপন চাবি নিরাপদে পৌঁছাতে হবে; যদি সেটা নিরাপদে পৌঁছানোই যায়, ভিডিওটাই সেভাবে পাঠানো যেত। (২) চাবি একবারের বেশি ব্যবহার করলেই সব ভেঙে পড়ে (অংশ ৩-এ হাতে-কলমে দেখবেন)। (৩) এটি শুধু গোপনীয়তা দেয়, অখণ্ডতা নয় — ciphertext-এর একটি bit উল্টালে plaintext-এর ঠিক সেই bit উল্টে যায়, আর প্রাপক টেরও পান না।

আধুনিক পথ: ছোট চাবি, “গণনাগতভাবে” নিরাপদ

আধুনিক cipher ছোট চাবি (১২৮ বা ২৫৬ bit) থেকে কাজ চালায়। নিরাপত্তার দাবি তখন: “চাবি না জেনে ভাঙার সবচেয়ে ভালো জানা পথ হলো সব চাবি একে একে চেষ্টা করা” — brute force. তাহলে প্রশ্ন দাঁড়ায়, সব চাবি চেষ্টা করতে কত সময়? একটি উদার হিসাব করি — আক্রমণকারীর পক্ষে সবকিছু বাড়িয়ে ধরে:

হিসাবটা নিজে মিলিয়ে দেখুন: 3.4 × 10³⁸ ÷ 10²¹ = 3.4 × 10¹⁷ সেকেন্ড; এক বছরে প্রায় 3.16 × 10⁷ সেকেন্ড, তাই ≈ 1.08 × 10¹⁰ বছর — মহাবিশ্বের বয়সের (প্রায় ১৩৮০ কোটি বছর) কাছাকাছি। গড়ে অর্ধেক চাবি চেষ্টা করলেই পাওয়া যায়, তবু সেটা ৫০০ কোটি বছরের বেশি। আর এখানে আমরা ধরে নিয়েছি পৃথিবীর প্রায় প্রতিটি মানুষের হাতে একটি করে অতি-দ্রুত যন্ত্র! প্রতি ১ bit বাড়ালে কাজ দ্বিগুণ হয় — এটাই exponential বৃদ্ধির শক্তি। ১৯৯৮ সালে EFF-এর বানানো একটি বিশেষ যন্ত্র (“Deep Crack”) ৫৬-bit DES-এর একটি চাবি প্রায় ৫৬ ঘণ্টায় বের করে দেখিয়েছিল যে DES-এর দিন শেষ।

৩ · Symmetric encryption — AES, mode আর nonce-এর নিয়ম

Symmetric encryption-এ তালা দেওয়া আর খোলার চাবি একই — বাসার দরজার চাবির মতো, যার কাছে কপি আছে সে-ই খুলতে পারে। এটি অত্যন্ত দ্রুত: আধুনিক CPU-তে AES-এর জন্য বিশেষ নির্দেশ (যেমন Intel/AMD-র AES-NI, ARM-এর crypto extension) থাকায় এক core সেকেন্ডে কয়েক GB এনক্রিপ্ট করতে পারে। তাই আপনার ভিডিও, ফাইল, ওয়েবপেজ — সব বড় ডেটা symmetric cipher দিয়েই চলে।

Block cipher আর AES

Block cipher একটি নির্দিষ্ট আকারের টুকরো (block) নিয়ে কাজ করে: চাবি ঠিক থাকলে প্রতিটি সম্ভাব্য ইনপুট block-কে একটি আলাদা আউটপুট block-এ নেয়, আর চাবি ছাড়া এই ম্যাপিং এলোমেলো দেখায়। AES (Advanced Encryption Standard) এর রাজা: block ১২৮ bit (১৬ বাইট), চাবি ১২৮, ১৯২ বা ২৫৬ bit, আর চাবির দৈর্ঘ্য অনুযায়ী ১০, ১২ বা ১৪ round. প্রতিটি round-এ চারটি কাজ: SubBytes (প্রতিটি বাইট একটি টেবিল দিয়ে বদলানো — অ-রৈখিকতা আনে), ShiftRows আর MixColumns (বাইটগুলো ছড়িয়ে-মিশিয়ে দেওয়া, যাতে একটি বাইটের প্রভাব পুরো block-এ যায়), আর AddRoundKey (round-এর চাবি XOR). শেষ round-এ MixColumns বাদ থাকে। ১৯৯৭–২০০০ সালের প্রকাশ্য প্রতিযোগিতায় বেলজিয়ামের Joan Daemen আর Vincent Rijmen-এর Rijndael জেতে, আর ২০০১ সালে NIST তা FIPS 197 হিসেবে প্রকাশ করে।

Mode — block cipher দিয়ে লম্বা বার্তা

AES একবারে মাত্র ১৬ বাইট নেয়। ১ MB ফাইল এনক্রিপ্ট করতে block-গুলো কীভাবে জোড়া হবে, সেই নিয়মকে বলে mode of operation. এখানেই বেশিরভাগ ভুল হয়:

“AEAD”-এর “AD” মানে associated data — যে অংশ এনক্রিপ্ট হয় না কিন্তু বদলানো যাবে না, যেমন packet-এর header. পর্ব ৩৩-এ (QUIC) দেখেছেন, QUIC-এর header খোলা থাকলেও AEAD tag-এ বাঁধা — পথের কোনো যন্ত্র header বদলালে প্রাপক packet ফেলে দেয়। AES-GCM-এ সাধারণত nonce ৯৬ bit আর tag ১২৮ bit.

Stream cipher আর nonce reuse — দুটি ciphertext XOR করলে কী হয়

CTR mode, ChaCha20 বা যেকোনো stream cipher আসলে একটি “নকল one-time pad”: চাবি আর nonce থেকে লম্বা keystream বানিয়ে plaintext-এর সাথে XOR. এখন যদি একই চাবি আর একই nonce দুটি বার্তায় ব্যবহার হয়, keystream-ও একই — আর তখন:

চাবি পুরো উধাও! আক্রমণকারী দুই plaintext-এর XOR পেয়ে গেল, আর একটি বার্তা আন্দাজ করতে পারলে (যেমন HTTP request-এর শুরু প্রায় সবসময় GET /) অন্যটি সরাসরি বেরিয়ে আসে। AES-GCM-এ nonce reuse আরও খারাপ: tag-এর গোপন অংশ বের করে জাল বার্তা বানানোও সম্ভব হয়। তাই নিয়ম: একই চাবিতে nonce কখনো দ্বিতীয়বার নয় — nonce এলোমেলো হতে পারে, বা একটি counter, কিন্তু অবশ্যই অনন্য। নিচের simulator-এ একটি খেলনা block cipher দিয়ে দুটি জিনিস দেখুন: ECB-তে ছবির নকশা ফাঁস হওয়া, আর একই nonce-এ দুটি বার্তার পরিণতি।

// Toy 32-bit block cipher (4-round Feistel) — শেখার জন্য, বাস্তবে ব্যবহার নিষেধ. Real: AES-GCM / ChaCha20-Poly1305.
const KEY = [0x3a7c, 0x91e5, 0x5d02, 0xc4b8];
function E(x) {                                   // encrypt one 4-byte block (as a 32-bit number)
  let L = x >>> 16, R = x & 0xffff;
  for (const k of KEY) [L, R] = [R, L ^ (((R * 0x9e37 + k) ^ (R >>> 5)) & 0xffff)];
  return ((L << 16) | R) >>> 0;
}
const toNum = (s) => [...s].reduce((a, c) => a * 256 + c.charCodeAt(0), 0);
const show = (c) => String.fromCharCode(65 + (c % 26)).repeat(4);   // one letter per cipher block
const img = ["########################", "########################",
             "........########........", "........########........", "........########........"];
console.log(`${"plaintext".padEnd(24)}  ${"ECB: same in -> same out".padEnd(24)}  CTR: every block new`);
let ctr = 0;
for (const row of img) {
  const blocks = row.match(/.{4}/g);
  const ecb = blocks.map(b => show(E(toNum(b)))).join("");
  const ctrRow = blocks.map(b => show((toNum(b) ^ E(0x1000 + ctr++)) >>> 0)).join("");
  console.log(`${row}  ${ecb}  ${ctrRow}`);
}
// Stream/CTR nonce reuse: same key + same nonce => same keystream for two messages.
const keystream = (len, nonce) => { const ks = [];
  for (let i = 0; ks.length < len; i++) { const w = E(nonce * 256 + i); ks.push(w >>> 24, (w >>> 16) & 255, (w >>> 8) & 255, w & 255); }
  return ks.slice(0, len); };
const xor = (a, b) => a.map((x, i) => x ^ b[i]), bytes = (s) => [...s].map(c => c.charCodeAt(0));
const P1 = bytes("TRANSFER 500 TK TO RAHIM"), P2 = bytes("MEET AT GATE 3 AT 9 PM!!");
const ks = keystream(P1.length, 7), C1 = xor(P1, ks), C2 = xor(P2, ks);   // nonce 7 used TWICE
console.log("\nC1 xor C2 == P1 xor P2 ?", xor(C1, C2).every((v, i) => v === xor(P1, P2)[i]));
console.log("attacker knows P1, recovers P2:", String.fromCharCode(...xor(xor(C1, C2), P1)));

plaintext                 ECB: same in -> same out  CTR: every block new
########################  IIIIIIIIIIIIIIIIIIIIIIII  LLLLKKKKUUUUQQQQRRRRMMMM
########################  IIIIIIIIIIIIIIIIIIIIIIII  SSSSNNNNMMMMCCCCJJJJGGGG
........########........  TTTTTTTTIIIIIIIITTTTTTTT  KKKKSSSSZZZZKKKKUUUUXXXX
........########........  TTTTTTTTIIIIIIIITTTTTTTT  CCCCCCCCVVVVHHHHVVVVAAAA
........########........  TTTTTTTTIIIIIIIITTTTTTTT  FFFFWWWWLLLLNNNNGGGGVVVV

C1 xor C2 == P1 xor P2 ? true
attacker knows P1, recovers P2: MEET AT GATE 3 AT 9 PM!!

৪ · Hash function — ডেটার আঙুলের ছাপ

জাতীয় পরিচয়পত্রে আপনার আঙুলের ছাপ থাকে। ছাপ দেখে আপনার চেহারা বানানো যায় না, কিন্তু দুজন মানুষের হুবহু এক ছাপ পাওয়া প্রায় অসম্ভব। একটি cryptographic hash ফাংশন ডেটার জন্য ঠিক এই কাজ করে: যেকোনো আকারের ইনপুট থেকে নির্দিষ্ট আকারের আউটপুট (SHA-256-এ ২৫৬ bit = ৬৪টি hex অক্ষর)। কোনো চাবি নেই — যে কেউ হিসাব করতে পারে। নিরাপত্তা আসে তিনটি গুণ থেকে:

1. Preimage resistance (এক-মুখী): শুধু hash h দেখে এমন কোনো x বের করা কার্যত অসম্ভব যাতে H(x) = h. ২৫৬-bit hash-এ সাধারণ চেষ্টায় প্রায় 2²⁵⁶ কাজ।
2. Second-preimage resistance: একটি নির্দিষ্ট x দেওয়া থাকলে আরেকটি x' ≠ x খোঁজা যাতে hash একই — কার্যত অসম্ভব। এটাই ডাউনলোড করা ফাইল যাচাইয়ের ভিত্তি।
3. Collision resistance: যেকোনো দুটি আলাদা ইনপুট খোঁজা যাদের hash একই — এটাও কঠিন, তবে birthday paradox-এর কারণে মাত্র প্রায় 2^n/2 কাজ লাগে।

আরেকটি প্রত্যাশিত বৈশিষ্ট্য avalanche effect: ইনপুটে একটিমাত্র bit বদলালে আউটপুটের প্রায় অর্ধেক bit উল্টে যায়, আর কোনগুলো উল্টাবে আগে থেকে বলা যায় না। ফলে “কাছাকাছি ইনপুট, কাছাকাছি hash” বলে কিছু নেই — hash দেখে ইনপুট সম্পর্কে আন্দাজ করার উপায় থাকে না।

Birthday bound — কেন n bit-এর hash-এ collision মাত্র 2^n/2-এ

একটি ক্লাসে কতজন থাকলে দুজনের জন্মদিন একই হওয়ার সম্ভাবনা ৫০% ছাড়ায়? উত্তর মাত্র ২৩ — অনেকের কাছে অবাক করা। কারণ আমরা একজনের সাথে নয়, যেকোনো দুজনের মিল খুঁজছি, আর ২৩ জনে জোড়া হয় ২৩ × ২২ / ২ = ২৫৩টি।

সাধারণ হিসাব: hash-এর সম্ভাব্য মান N = 2ⁿটি, আর আমরা k টি এলোমেলো ইনপুট hash করলাম। কোনো মিল না হওয়ার সম্ভাবনা

(এখানে ছোট x-এর জন্য 1 − x ≈ e^−x আর 1 + 2 + … + (k−1) = k(k−1)/2 ব্যবহার করেছি)। এটি ½ হলে k² = 2N·ln 2, অর্থাৎ k ≈ 1.177 √N = 1.177 × 2^n/2. প্রথম collision পর্যন্ত গড় চেষ্টা √(πN/2) ≈ 1.25 √N. জন্মদিনে N = 365: 1.177 × √365 ≈ ২২.৫ — সেই ২৩! ২৪-bit hash-এ √N = 2¹² = ৪০৯৬; SHA-256-এ 2¹²⁸ — নিরাপদ। তাই hash-এর আকার নিরাপত্তার দ্বিগুণ রাখা হয়: ১২৮-bit নিরাপত্তার জন্য ২৫৬-bit hash.

নিচের কোডটি একটি ছোট, বিশুদ্ধ JavaScript-এ লেখা SHA-256 (FIPS 180-4 অনুযায়ী) — প্রথমে আনুষ্ঠানিক test vector দিয়ে নিজেকে যাচাই করে, তারপর avalanche মাপে, তারপর hash-কে ২৪ bit-এ ছেঁটে collision খোঁজে। (ব্রাউজারে আসল কাজে নিজে না লিখে crypto.subtle.digest("SHA-256", data) ব্যবহার করবেন; এখানে নিজে লেখা হয়েছে ভেতরটা দেখানোর জন্য।)

// Compact SHA-256 (FIPS 180-4) for ASCII text, then avalanche and birthday experiments.
const K = [], H0 = [], frac = (x) => ((x - Math.floor(x)) * 2 ** 32) >>> 0;
for (let n = 2, c = 0; c < 64; n++) if (![2, 3, 5, 7, 11, 13, 17, 19].some(d => d < n && n % d === 0)) {
  if (c < 8) H0.push(frac(n ** 0.5)); K.push(frac(n ** (1 / 3))); c++; }
function sha256(str) {
  const b = [...str].map(c => c.charCodeAt(0)), L = b.length * 8; b.push(0x80);
  while (b.length % 64 !== 56) b.push(0);
  for (let i = 7; i >= 0; i--) b.push(i > 3 ? 0 : (L >>> (i * 8)) & 255);
  const H = H0.slice(), w = [], r = (x, n) => (x >>> n) | (x << (32 - n));
  for (let o = 0; o < b.length; o += 64) {
    for (let i = 0; i < 64; i++) w[i] = i < 16 ? (b[o+4*i] << 24 | b[o+4*i+1] << 16 | b[o+4*i+2] << 8 | b[o+4*i+3])
      : (w[i-16] + (r(w[i-15], 7) ^ r(w[i-15], 18) ^ (w[i-15] >>> 3)) + w[i-7] + (r(w[i-2], 17) ^ r(w[i-2], 19) ^ (w[i-2] >>> 10))) | 0;
    let [a, bb, c, d, e, f, g, h] = H;
    for (let i = 0; i < 64; i++) {
      const t1 = (h + (r(e, 6) ^ r(e, 11) ^ r(e, 25)) + ((e & f) ^ (~e & g)) + K[i] + w[i]) | 0;
      const t2 = ((r(a, 2) ^ r(a, 13) ^ r(a, 22)) + ((a & bb) ^ (a & c) ^ (bb & c))) | 0;
      [h, g, f, e, d, c, bb, a] = [g, f, e, (d + t1) | 0, c, bb, a, (t1 + t2) | 0];
    }
    [a, bb, c, d, e, f, g, h].forEach((v, i) => H[i] = (H[i] + v) | 0);
  }
  return H.map(x => (x >>> 0).toString(16).padStart(8, "0")).join("");
}
console.log(`sha256("abc") = ${sha256("abc")}`);           // FIPS test vector ba7816bf...f20015ad
const m1 = "Pay 500 Tk to Rahim", m2 = "Pay 400 Tk to Rahim";  // '5'=0x35, '4'=0x34: ONE bit differs
const h1 = sha256(m1), h2 = sha256(m2);
const diff = [...Array(64).keys()].reduce((s, i) => s + [...(parseInt(h1[i], 16) ^ parseInt(h2[i], 16)).toString(2)].filter(x => x === "1").length, 0);
console.log(`${m1} -> ${h1.slice(0, 32)}...\n${m2} -> ${h2.slice(0, 32)}...\nbits changed: ${diff} of 256`);
// Birthday: keep only 24 bits (6 hex digits) of the hash; how many messages until two collide?
const found = [];
for (let trial = 0; trial < 10; trial++) {
  const seen = new Map();
  for (let i = 0; ; i++) { const t = sha256(`trial${trial}-msg${i}`).slice(0, 6);
    if (seen.has(t)) { found.push(i + 1); break; } seen.set(t, i); }
}
console.log(`24-bit hash, messages until first collision: ${found.join(", ")}\navg = ${Math.round(found.reduce((s, x) => s + x) / found.length)}; 2^12 = 4096, sqrt(pi/2 * 2^24) ~ 5134`);

sha256("abc") = ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
Pay 500 Tk to Rahim -> 717052a71bb45e8c557efc4a8d719ae7...
Pay 400 Tk to Rahim -> fbaf6da3cb038d26b701bf129f6b3bd8...
bits changed: 135 of 256
24-bit hash, messages until first collision: 1442, 2509, 4107, 3623, 5475, 4628, 6709, 5117, 3067, 3756
avg = 4043; 2^12 = 4096, sqrt(pi/2 * 2^24) ~ 5134

SHA-2, SHA-3 আর ভাঙা MD5, SHA-1

নিজের Linux বা macOS-এ (OpenSSL থাকলে) hash আর random বাইট দেখতে পারেন। নিচের উদাহরণটি OpenSSL 3.x চালানো একটি সাধারণ Linux যন্ত্রের — শেষ লাইনটি এলোমেলো, তাই আপনারটি আলাদা আসবে:

$ command -v openssl >/dev/null && openssl version || echo "openssl নেই"
OpenSSL 3.0.13 30 Jan 2024 (Library: OpenSSL 3.0.13 30 Jan 2024)
$ printf 'ABCL TECH' | openssl dgst -sha256
SHA2-256(stdin)= 3e8e9fd76e3152fbdc4a35b41b3b12595fe5d5e70eaa2f472bb7554f59d97a2d
$ echo 'ABCL TECH' | openssl dgst -sha256        # echo শেষে \n যোগ করে
SHA2-256(stdin)= 314378fee1bdc3d5889810f6b05135cb2e5978621ac3f87bce7eb0cc7074b3f3
$ openssl rand -hex 16                           # CSPRNG থেকে ১২৮-bit চাবি
5f0c9e2a71d4b83e06a7c1f92d4e8b10

খেয়াল করুন দ্বিতীয় আর তৃতীয় কমান্ড: echo লেখার শেষে একটি অদৃশ্য newline যোগ করে, আর সেই এক বাইটেই পুরো hash বদলে গেছে — avalanche-এর বাস্তব রূপ, আর “আমার hash মিলছে না কেন” প্রশ্নের সবচেয়ে সাধারণ উত্তর। পুরোনো OpenSSL (1.1.x) একই hash দেখায়, শুধু শুরুতে (stdin)= লেখে। Windows-এ PowerShell-এর Get-FileHash ফাইলের SHA-256 দেখায়।

৫ · MAC, HMAC আর password রাখার নিয়ম

Hash একা অখণ্ডতা দেয় না, যদি আক্রমণকারী বার্তা আর hash দুটোই বদলাতে পারে — CRC-র মতোই সমস্যা। দরকার এমন একটি ছাপ যা শুধু চাবিধারী বানাতে পারে: MAC (message authentication code). প্রেরক tag = MAC(K, বার্তা) পাঠান; প্রাপক একই চাবিতে আবার হিসাব করে মেলান। মিললে বোঝা যায় বার্তা অক্ষত, আর এসেছে চাবিধারী কারো কাছ থেকে। পর্ব ২৯-এর SYN cookie-তেও সার্ভার একটি গোপন চাবিসহ hash ব্যবহার করে, যাতে বাইরের কেউ বৈধ cookie বানাতে না পারে।

কেন SHA-256(key ‖ message) চলবে না

সহজ বুদ্ধি বলে চাবি আর বার্তা জুড়ে hash করলেই MAC হয়ে যায়। কিন্তু SHA-256 (আর MD5, SHA-1) Merkle–Damgård কাঠামোয় তৈরি: বার্তাকে ৬৪-বাইটের টুকরোয় ভাগ করে একটি অভ্যন্তরীণ অবস্থা ধাপে ধাপে বদলায়, আর শেষ অবস্থাটাই hash. ফলে H(key ‖ m) জানা থাকলে আক্রমণকারী সেখান থেকে hash চালিয়ে যেতে পারে — চাবি না জেনেই key ‖ m ‖ padding ‖ extra-এর বৈধ hash বানাতে পারে। একে বলে length extension attack; একসময় কিছু জনপ্রিয় ওয়েব API এমন ভুলে জাল অনুরোধ মেনে নিত বলে প্রকাশ্যে দেখানো হয়েছিল। SHA-3 আর BLAKE2-এর নকশায় এই দুর্বলতা নেই, কিন্তু প্রমিত সমাধান হলো HMAC (Bellare, Canetti, Krawczyk, ১৯৯৬; RFC 2104): চাবি দুবার, দুটি আলাদা ধ্রুবকের সাথে মিশিয়ে hash-এর ভেতরে hash.

Password কখনো সাধারণ hash-এ নয়

ওয়েবসাইট আপনার password নিজে রাখবে না, রাখবে তার একটি ছাপ; লগইনের সময় নতুন করে হিসাব করে মেলাবে। কিন্তু SHA-256(password) রাখা বিপজ্জনক, দুই কারণে:

• খুব দ্রুত: SHA-256 দ্রুত হওয়ার জন্যই বানানো। একটি আধুনিক GPU সেকেন্ডে শত শত কোটি SHA-256 হিসাব করতে পারে। ৮ অক্ষরের ছোট হাতের ইংরেজি password-এর সম্ভাব্য সংখ্যা 26⁸ ≈ ২০,৮৮৩ কোটি; সেকেন্ডে ১,০০০ কোটি চেষ্টায় সব শেষ প্রায় ২১ সেকেন্ডে।
• একই password, একই hash: হাজার জনের password “123456” হলে সবার hash এক — আগে থেকে বানানো তালিকা (rainbow table) দিয়ে একবারে সবাই ধরা পড়েন।

সমাধান দুটি হাতিয়ারের জোড়া। প্রতিটি ব্যবহারকারীর জন্য আলাদা এলোমেলো salt (যেমন ১৬ বাইট), যা hash-এর পাশে খোলাই রাখা হয় — এতে একই password-এর hash-ও আলাদা হয় আর আগে বানানো তালিকা অকেজো হয়। আর ইচ্ছা করে ধীর, মেমরি-খেকো একটি password hashing ফাংশন: Argon2id (২০১৫ সালের Password Hashing Competition-জয়ী, RFC 9106), scrypt (২০০৯), bcrypt (১৯৯৯), বা মান্য নির্দেশিকা মেনে বড় iteration-এর PBKDF2. এগুলোকে key derivation function (KDF)-ও বলে। লগইনে ১০০ মিলিসেকেন্ড লাগলে ব্যবহারকারী টেরও পান না, কিন্তু আক্রমণকারীর প্রতিটি আন্দাজ লাখো গুণ দামি হয়ে যায়; আর Argon2 বা scrypt প্রতিটি চেষ্টায় অনেক মেমরি চায় বলে GPU-র হাজার core একসাথে কাজে লাগানো কঠিন। কখনো password এনক্রিপ্ট করে রাখবেন না (চাবি চুরি গেলে সব খোলা), আর কখনো plain SHA-256 বা MD5 নয়।

৬ · Public key আর Diffie–Hellman — খোলা রাস্তায় গোপন চাবি

Symmetric cipher-এর একটি বড় প্রশ্ন বাকি: চাবিটি দুই পক্ষের কাছে পৌঁছাবে কীভাবে? চট্টগ্রামের একজন গ্রাহক যখন প্রথমবার একটি ঢাকার ই-কমার্স সাইটে ঢোকেন, আগে থেকে কোনো গোপন চাবি ভাগ করা নেই। প্রতিটি সাইটের জন্য কুরিয়ারে চাবি পাঠানো অসম্ভব; n জন মানুষের প্রত্যেক জোড়ার জন্য আলাদা চাবি লাগলে মোট n(n−1)/2টি চাবি — ১০০ কোটি ব্যবহারকারীর জন্য প্রায় ৫ × ১০^১৭টি। এটাই key distribution-এর সমস্যা।

১৯৭৬ সালে Whitfield Diffie আর Martin Hellman তাঁদের “New Directions in Cryptography” প্রবন্ধে দেখান, দুজন মানুষ সবার সামনে কথা বলেও একটি গোপন সংখ্যায় একমত হতে পারেন। ভিত্তি একটি এক-মুখী গণিত: modular exponentiation ga mod p হিসাব করা সহজ (square-and-multiply-এ প্রায় log₂a ধাপ), কিন্তু ফল দেখে a বের করা — discrete logarithm — বড় p-এর জন্য কার্যত অসম্ভব। (Modular arithmetic আর দ্রুত ঘাতের গণিত DSA কোর্সের Number theory — GCD, sieve আর modular arithmetic পর্বে বিস্তারিত আছে।)

MITM — কেন শুধু DH যথেষ্ট নয়

Eve শুধু শুনলে DH নিরাপদ। কিন্তু সক্রিয় আক্রমণকারী Mallory যদি মাঝখানে বসে Alice-এর A আটকে Bob-কে নিজের M পাঠান, আর Bob-এর B আটকে Alice-কে M পাঠান? তখন Alice-এর চাবি হয় Mallory-র সাথে, Bob-এর চাবিও Mallory-র সাথে — দুজনেই ভাবেন একে অপরের সাথে কথা বলছেন। এটাই man-in-the-middle. DH বলে “আমরা দুজন একই গোপন চাবি পেলাম”, কিন্তু বলে না “আমি কার সাথে চাবি পেলাম”। নিচের simulator-এ দুটোই দেখুন:

// Toy Diffie–Hellman (p = 23) — শেখার জন্য, বাস্তবে ব্যবহার নিষেধ (real p: 2048+ bits or X25519).
const modPow = (b, e, m) => { let r = 1; b %= m;
  for (; e > 0; e >>= 1, b = b * b % m) if (e & 1) r = r * b % m; return r; };
const p = 23, g = 5;
const a = 6, b = 15;                          // secrets: never sent
const A = modPow(g, a, p), B = modPow(g, b, p);  // public values: sent in the open
console.log(`public: p=${p}, g=${g}; Alice sends A=${A}, Bob sends B=${B}`);
console.log(`Alice: B^a mod p = ${modPow(B, a, p)} | Bob: A^b mod p = ${modPow(A, b, p)}`);
// Passive Eve sees p, g, A, B. With p=23 she can simply try every exponent:
const tries = [...Array(p - 1).keys()].filter(x => modPow(g, x, p) === A);
console.log(`Eve brute-forces g^x = A: x in [${tries}] -> key ${modPow(B, tries[0], p)} (why p must be huge)`);
// Active Mallory sits in the middle and swaps A and B with her own value M.
const m = 13, M = modPow(g, m, p);
const kAlice = modPow(M, a, p), kBob = modPow(M, b, p);
console.log(`\nMITM: Mallory sends M=${M} to both sides`);
console.log(`Alice thinks key with Bob = ${kAlice}; Mallory's copy = ${modPow(A, m, p)}`);
console.log(`Bob thinks key with Alice = ${kBob}; Mallory's copy = ${modPow(B, m, p)}`);
console.log(`Alice and Bob keys equal? ${kAlice === kBob} -> Mallory decrypts, reads, re-encrypts`);
// Defence = authentication: compare a fingerprint of the key over another channel
// (like a safety number), or have the server SIGN its value (TLS certificates, lesson 48).
console.log(`fingerprint check by phone: Alice ${kAlice} vs Bob ${kBob} -> ${kAlice === kBob ? "same" : "MISMATCH, abort"}`);

public: p=23, g=5; Alice sends A=8, Bob sends B=19
Alice: B^a mod p = 2 | Bob: A^b mod p = 2
Eve brute-forces g^x = A: x in [6] -> key 2 (why p must be huge)

MITM: Mallory sends M=21 to both sides
Alice thinks key with Bob = 18; Mallory's copy = 18
Bob thinks key with Alice = 7; Mallory's copy = 7
Alice and Bob keys equal? false -> Mallory decrypts, reads, re-encrypts
fingerprint check by phone: Alice 18 vs Bob 7 -> MISMATCH, abort

৭ · RSA, elliptic curve আর digital signature

DH চাবিতে একমত করায়; কিন্তু “যে কেউ আমার জন্য তালা দিতে পারবে, খুলতে পারব শুধু আমি” — এমন তালা কি সম্ভব? ১৯৭৭ সালে MIT-র Ron Rivest, Adi Shamir আর Leonard Adleman দেখান সম্ভব: RSA. এটাই public key cryptography-র সবচেয়ে পরিচিত রূপ — প্রত্যেকের একজোড়া চাবি: সবার জন্য খোলা public key আর শুধু নিজের কাছে রাখা private key. ডাকঘরের চিঠির বাক্সের মতো — ফোকর দিয়ে যে কেউ চিঠি ফেলতে পারে, কিন্তু বাক্স খোলার চাবি শুধু পোস্টমাস্টারের কাছে।

RSA হাতে-কলমে (p = 61, q = 53)

1. দুটি গোপন মৌলিক সংখ্যা: p = 61, q = 53. n = p·q = 3233 — এটি public.
2. φ(n) = (p−1)(q−1) = 60 × 52 = 3120 — গোপন; p, q না জানলে বের করা কঠিন।
3. e = 17 বাছাই, যাতে gcd(e, φ) = 1. (বাস্তবে প্রায় সবসময় e = 65537.)
4. d = e⁻¹ mod φ, extended Euclid দিয়ে: 3120 = 17·183 + 9; 17 = 9·1 + 8; 9 = 8·1 + 1. উল্টো দিকে: 1 = 9 − 8 = 9 − (17 − 9) = 2·9 − 17 = 2·(3120 − 183·17) − 17 = 2·3120 − 367·17. তাই d ≡ −367 ≡ 3120 − 367 = 2753. যাচাই: 17 × 2753 = 46801 = 15 × 3120 + 1 ✓.
5. Public key = (n, e) = (3233, 17); private key = d = 2753. Encrypt: c = m^e mod n; decrypt: m = c^d mod n. m = 65 হলে c = 65¹⁷ mod 3233 = 2790, আর 2790²⁷⁵³ mod 3233 = 65 ফেরত আসে।

কেন কাজ করে? e·d = 1 + kφ(n). Euler-এর উপপাদ্য বলে gcd(m, n) = 1 হলে m^φ(n) ≡ 1 (mod n). তাই c^d = m^ed = m · (m^φ(n))^k ≡ m · 1^k = m (mod n). (gcd ≠ 1 হলেও Chinese remainder theorem দিয়ে ফলটি সত্য প্রমাণ করা যায়।) নিরাপত্তা দাঁড়িয়ে আছে factoring-এর কাঠিন্যে: n থেকে p আর q বের করতে পারলেই φ, তারপর d. 3233 হাতে ভাঙা যায়; ২০৪৮-bit (প্রায় ৬১৭ অঙ্কের) n ভাঙার কোনো জানা ব্যবহারিক উপায় নেই।

Digital signature — উল্টো দিকে চাবি

RSA-তে চাবি দুটির ভূমিকা উল্টে দিলে সই হয়: private key দিয়ে “এনক্রিপ্ট” করলে যে কেউ public key দিয়ে মিলিয়ে দেখতে পারেন, কিন্তু বানাতে পারেন শুধু private key-র মালিক। বাস্তবে পুরো বার্তা নয়, তার hash সই করা হয় (hash-then-sign) — বার্তা যত বড়ই হোক, সই ছোট থাকে। নিচের stepper-এ আরও ছোট সংখ্যায় পুরোটা হাতে মেলানো যায়:

এবার BigInt দিয়ে পুরো RSA চালিয়ে দেখুন — key তৈরি (extended Euclid সহ), encrypt/decrypt আর sign/verify, যেখানে বদলানো বার্তা ধরা পড়ে:

// Toy RSA with BigInt — শেখার জন্য, বাস্তবে ব্যবহার নিষেধ (tiny primes, no padding).
const modPow = (b, e, m) => { let r = 1n; b %= m;
  for (; e > 0n; e >>= 1n, b = b * b % m) if (e & 1n) r = r * b % m; return r; };
function egcd(a, b) {            // returns [g, x, y] with a*x + b*y = g
  if (b === 0n) return [a, 1n, 0n];
  const [g, x, y] = egcd(b, a % b); return [g, y, x - (a / b) * y];
}
const p = 61n, q = 53n, n = p * q, phi = (p - 1n) * (q - 1n), e = 17n;
const [g, x] = egcd(e, phi), d = ((x % phi) + phi) % phi;
console.log(`n = ${n}, phi = ${phi}, e = ${e}, gcd(e,phi) = ${g}, d = ${d}`);
console.log(`check: e*d mod phi = ${e * d % phi}`);
const m = 65n, c = modPow(m, e, n);                  // encrypt with PUBLIC (e, n)
console.log(`encrypt m=${m}: c = ${m}^${e} mod ${n} = ${c}`);
console.log(`decrypt: c^d mod n = ${modPow(c, d, n)}`);  // decrypt with PRIVATE d
// toy "hash" of a message into 0..n-1 (NOT a real hash; real RSA signs SHA-256 + PSS)
const h = (s) => [...s].reduce((a, ch) => (a * 31n + BigInt(ch.charCodeAt(0))) % n, 7n);
const msg = "Pay 500 Tk to Rahim", hm = h(msg);
const sig = modPow(hm, d, n);                         // sign with PRIVATE d
console.log(`\nmsg = "${msg}", h = ${hm}, signature s = h^d mod n = ${sig}`);
for (const recv of [msg, "Pay 900 Tk to Rahim"]) {
  const back = modPow(sig, e, n), want = h(recv);     // verify with PUBLIC e
  console.log(`verify "${recv}": s^e mod n = ${back}, h(recv) = ${want} -> ${back === want ? "VALID" : "INVALID (tampered)"}`);
}

n = 3233, phi = 3120, e = 17, gcd(e,phi) = 1, d = 2753
check: e*d mod phi = 1
encrypt m=65: c = 65^17 mod 3233 = 2790
decrypt: c^d mod n = 65

msg = "Pay 500 Tk to Rahim", h = 186, signature s = h^d mod n = 2711
verify "Pay 500 Tk to Rahim": s^e mod n = 186, h(recv) = 186 -> VALID
verify "Pay 900 Tk to Rahim": s^e mod n = 186, h(recv) = 37 -> INVALID (tampered)

Elliptic curve — ছোট চাবি, একই নিরাপত্তা

Elliptic curve cryptography (ECC)-তে সংখ্যার ঘাতের বদলে একটি বক্ররেখার বিন্দু বারবার “যোগ” করা হয়; বিন্দু P আর ফল kP দেখে k বের করার সমস্যাটি সাধারণ discrete log-এর চেয়েও কঠিন বলে জানা যায়। ফলে অনেক ছোট চাবিতে একই নিরাপত্তা। NIST-এর প্রচলিত তুলনায় (SP 800-57) মোটামুটি: ২৫৬-bit ECC ≈ ৩০৭২-bit RSA ≈ ১২৮-bit symmetric; ২২৪-bit ECC ≈ ২০৪৮-bit RSA ≈ ১১২-bit. এসব সমতা আনুমানিক, কারণ আক্রমণের সেরা algorithm-এর হিসাবের ওপর নির্ভর করে। আজকের জনপ্রিয় রূপ: X25519 (ECDH key exchange, RFC 7748 — আজ বহু TLS 1.3 সংযোগের প্রথম পছন্দ), Ed25519 (সই, RFC 8032 — SSH key-তে খুব প্রচলিত), আর ECDSA P-256 (certificate-এ বহুল ব্যবহৃত, কিন্তু প্রতিটি সইয়ে নতুন গোপন সংখ্যা লাগে — PS3-র ঘটনা মনে করুন)। X25519-এর public key মাত্র ৩২ বাইট, যেখানে ৩০৭২-bit RSA-র modulus ৩৮৪ বাইট — ফোনে আর handshake-এ এই পার্থক্য বড়।

পর্ব ৩৯-এ (ইমেইল) DKIM দেখেছেন: পাঠানো সার্ভার header আর body-র hash-এ সই করে, প্রাপক DNS থেকে public key এনে যাচাই করে — ঠিক এই hash-then-sign. আবার একটি সই শুধু বলে “এই private key-র মালিক সই করেছেন” — ওই public key সত্যিই bank.example-এর কি না, তা বলে না। সেই সংযোগ বানায় certificate আর বিশ্বাসের শিকল (PKI), যা পর্ব ৪৮-এর পুরো বিষয়।

৮ · সব জোড়া লাগানো — hybrid encryption, randomness, post-quantum আর সোনালি নিয়ম

Hybrid encryption — দুই জগতের সেরাটা

Public key ধীর (RSA বা ECDH-এর একটি কাজে symmetric-এর চেয়ে হাজার গুণ বা তার বেশি সময়), কিন্তু চাবি বিতরণের সমস্যা মেটায়; symmetric দ্রুত, কিন্তু আগে থেকে চাবি চায়। সমাধান — দুটো একসাথে, আর ঠিক এভাবেই HTTPS চলে:

Randomness — সব চাবির উৎস

প্রতিটি চাবি, nonce, salt আর DH-এর গোপন সংখ্যা আসে random number থেকে। সাধারণ Math.random() বা C-র rand() খেলা আর simulation-এর জন্য — কয়েকটি আউটপুট দেখে পরেরগুলো আন্দাজ করা যায়। চাবির জন্য দরকার CSPRNG (cryptographically secure pseudo-random number generator), যা OS হার্ডওয়্যারের অনিশ্চয়তা (entropy) — interrupt-এর সময়, CPU-র হার্ডওয়্যার RNG — জড়ো করে বানায়। Linux-এ getrandom() system call (kernel 3.17 থেকে) বা /dev/urandom; Windows-এ BCryptGenRandom; ব্রাউজারে crypto.getRandomValues(); Python-এ secrets module.

এখানে ভুলের দাম ভয়াবহ। ২০০৮ সালের মে মাসে জানা যায় (CVE-2008-0166), Debian-এর OpenSSL প্যাকেজে ২০০৬ সালে একটি “পরিষ্কারের” পরিবর্তনে entropy জোগানোর লাইন বাদ পড়েছিল; ফলে random অবস্থা প্রায় শুধু process ID-র ওপর নির্ভর করত — প্রতিটি ধরন আর আকারের জন্য মাত্র কয়েক হাজার (৩২,৭৬৮-র মতো) সম্ভাব্য চাবি। প্রায় দুই বছর ধরে Debian আর Ubuntu-তে বানানো SSH ও TLS চাবি তালিকা ধরে ভাঙা যেত, আর সেগুলো খুঁজে বাতিল করতে হয়েছিল।

Post-quantum cryptography

১৯৯৪ সালে Peter Shor দেখান, যথেষ্ট বড় ও ত্রুটি-সংশোধিত quantum computer factoring আর discrete log দুটোই দ্রুত (polynomial সময়ে) করতে পারবে — অর্থাৎ RSA, DH, ECDH, ECDSA সবই ভাঙবে (Shor-এর algorithm). Symmetric cipher আর hash-এর ক্ষতি তুলনায় কম: Grover-এর algorithm (১৯৯৬) তাত্ত্বিকভাবে brute force-কে বর্গমূলে নামায়, তাই দীর্ঘমেয়াদে AES-256 পছন্দ করা হয়। এমন যন্ত্র কবে আসবে কেউ নিশ্চিত জানে না; কিন্তু “আজ রেকর্ড, পরে ডিক্রিপ্ট” (harvest now, decrypt later) ঝুঁকির কারণে দীর্ঘদিন গোপন রাখার তথ্যের জন্য এখনই প্রস্তুতি চলছে। ২০২৪ সালের আগস্টে NIST প্রথম post-quantum মানদণ্ড প্রকাশ করে: FIPS 203 — ML-KEM (Kyber থেকে, key exchange), FIPS 204 — ML-DSA (Dilithium থেকে, সই), আর FIPS 205 — SLH-DSA (hash-ভিত্তিক সই)। প্রধান ব্রাউজার আর বড় CDN-গুলো ২০২৪ সাল থেকে TLS-এ hybrid key exchange (X25519 আর ML-KEM-768 একসাথে, যাতে যেকোনো একটি টিকলেই নিরাপদ) চালু করতে শুরু করেছে বলে তাদের প্রকাশিত ঘোষণায় জানা যায় — কোন সংস্করণে কোনটি ডিফল্ট, তা দ্রুত বদলাচ্ছে। দাম আছে: ML-KEM-768-এর public key ১১৮৪ বাইট, ciphertext ১০৮৮ বাইট — X25519-এর ৩২ বাইটের তুলনায় অনেক বড়, তাই handshake-এর packet বড় হয়।

সোনালি নিয়ম

• নিজে crypto বানাবেন না — নিজের cipher তো নয়ই, নিজের “AES + HMAC জোড়া”-ও নয়। যাচাই করা উচ্চ-স্তরের API ব্যবহার করুন: libsodium (crypto_secretbox, crypto_box), OpenSSL বা BoringSSL, ব্রাউজারে WebCrypto, Go-র crypto, Python-এর cryptography.
• ডিফল্ট পছন্দ: AEAD (AES-256-GCM বা ChaCha20-Poly1305), X25519, Ed25519, SHA-256 বা তার ওপরে, password-এ Argon2id
• চাবি, nonce, salt সবসময় CSPRNG থেকে; একই চাবিতে nonce কখনো দুবার নয়
• MAC বা token তুলনায় constant-time ফাংশন (crypto.timingSafeEqual, hmac.compare_digest, CRYPTO_memcmp)
• Key management-ই আসল কঠিন কাজ: চাবি কোডে বা Git-এ নয়; KMS বা HSM-এ রাখা, কে ব্যবহার করতে পারবে সীমিত রাখা, নিয়মিত বদলানো, আর চুরি হলে কী করবেন আগেই ঠিক করে রাখা

৯ · AI-এর যুগে cryptography — দেখতে ঠিক, আসলে ভাঙা

Crypto কোড বিপজ্জনকভাবে “চলে”: ভুল mode, স্থির IV বা দুর্বল random-এও ফাইল এনক্রিপ্ট হয়, ডিক্রিপ্টও হয়, test pass করে — শুধু নিরাপত্তা থাকে না। AI প্রায়ই পুরোনো টিউটোরিয়াল থেকে শেখা এমন কোড আত্মবিশ্বাসের সাথে দেয়। আর নেটওয়ার্কিংয়ের অন্য কাজের মতো এখানেও AI পুরোনো কমান্ড, এক vendor-এর নিয়মকে সার্বজনীন বলা, আর বানানো RFC নম্বর দেয়। চেনা ভুলগুলো:

AI-এর crypto কোড চালুর আগে — চেকলিস্ট

• কোডে কোনো নিজে-বানানো cipher, mode বা “চালাক” XOR কৌশল নেই; সব কাজ পরিচিত library-র উচ্চ-স্তরের ফাংশনে
• Known-answer test চালিয়েছি — যেমন SHA-256("abc") = ba7816bf…f20015ad, বা RFC-র HMAC/AEAD test vector
• একই ইনপুট দুবার এনক্রিপ্ট করে আলাদা ciphertext পেয়েছি; একটি বাইট বদলে ডিক্রিপ্ট ব্যর্থ হতে দেখেছি
• চাবি কোড, লগ বা Git-এ নেই; random-এর উৎস CSPRNG
• নিজের ল্যাব বা VM-এ চালিয়ে পরীক্ষা করেছি, আর প্রয়োজনে নিজের সংযোগের packet capture করে দেখেছি তারে সত্যিই এনক্রিপ্ট করা বাইট যাচ্ছে; RFC নম্বর আর কমান্ডের flag man page ও rfc-editor.org-এ মিলিয়েছি