Cryptographic Hash Function — ফিঙ্গারপ্রিন্ট, চাবি ছাড়াই

লক্ষ্য: H(secret || message)-কে সরাসরি MAC হিসেবে ব্যবহার করা কেন বিপজ্জনক — attacker secret না জেনেই একটা valid extended tag বানিয়ে ফেলবে, শুধু original tag আর length জেনেই।

# length_ext.py — toy Merkle-Damgard hash-এ length-extension attack
import hashlib

BLOCK = 8   # bytes/block — ছোট রাখা হয়েছে demo readable রাখতে
IV = b"\x01\x23\x45\x67\x89\xab\xcd\xef"

def compress(state, block):
    # toy compression function — SHA-256 real cipher-এর জায়গায় stand-in,
    # কিন্তু ঠিক একই কাঠামোগত ভূমিকা: state+block -> নতুন state
    assert len(block) == BLOCK
    return hashlib.sha256(state + block).digest()[:BLOCK]

def md_pad(total_len):
    # Merkle-Damgard padding: 0x80, তারপর শূন্য, শেষে ৮-byte bit-length
    pad = b"\x80"
    while (total_len + len(pad)) % BLOCK != 0:
        pad += b"\x00"
    pad += (total_len * 8).to_bytes(8, "big")
    return pad

def toy_hash(message):
    state, data = IV, message + md_pad(len(message))
    for i in range(0, len(data), BLOCK):
        state = compress(state, data[i:i + BLOCK])
    return state

def toy_hash_continue(state, prior_len, extra):
    # আগে prior_len byte প্রসেস হয়ে state-এ পৌঁছানো হয়েছে ধরে নিয়ে,
    # extra যোগ করে নতুন মোট-length অনুযায়ী শেষ-padding বসায়
    total_len = prior_len + len(extra)
    data = extra + md_pad(total_len)
    for i in range(0, len(data), BLOCK):
        state = compress(state, data[i:i + BLOCK])
    return state

# ---------- ভিকটিম সিস্টেম: MAC = toy_hash(secret || message) ----------
SECRET = b"k3y!!!!!"                      # attacker এটা জানে না
message = b"uid=1001&role=user"
tag = toy_hash(SECRET + message)
print(f"victim tag = toy_hash(secret||message) = {tag.hex()}")

# ---------- attacker: শুধু tag, message, len(secret) আন্দাজ জানে ----------
GUESSED_SECRET_LEN = len(SECRET)          # বাস্তবে brute-force/known-length
extension = b"&role=admin"

L = GUESSED_SECRET_LEN + len(message)
glue = md_pad(L)                          # victim-এর hash ঠিক এখানেই padding বসিয়েছিল
forged_tag = toy_hash_continue(tag, L + len(glue), extension)
forged_message = message + glue + extension

print(f"attacker forged_tag              = {forged_tag.hex()}")
print(f"attacker sends forged_message    = {forged_message!r}")

# ---------- সার্ভার-সাইড ভেরিফিকেশন: real secret দিয়ে recompute ----------
server_check = toy_hash(SECRET + forged_message)
print(f"server recompute toy_hash(secret||forged_message) = {server_check.hex()}")
print(f"forged_tag MATCHES server recompute : {forged_tag == server_check}")
print("-> attacker secret না জেনেই একটা valid tag বানিয়ে ফেলল role=admin যোগ করে!")

# ---------- HMAC-স্টাইল fix: নেস্টেড হ্যাশ attacker-কে আটকায় ----------
def hmac_style(secret, message):
    inner = toy_hash(secret + message)
    return toy_hash(secret + inner)       # বাইরের hash-এ আবার secret লাগবে

real_hmac = hmac_style(SECRET, message)
print(f"\nHMAC-style tag = {real_hmac.hex()}")
print("attacker-এর কাছে কোনো উপায় নেই বাইরের hash extend করার — SECRET ছাড়া অসম্ভব।")

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

victim tag = toy_hash(secret||message) = f3eed9251e5f62ef
attacker forged_tag              = 6a12f8777cff103e
attacker sends forged_message    = b'uid=1001&role=user\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0&role=admin'
server recompute toy_hash(secret||forged_message) = 6a12f8777cff103e
forged_tag MATCHES server recompute : True
-> attacker secret না জেনেই একটা valid tag বানিয়ে ফেলল role=admin যোগ করে!

HMAC-style tag = ab1f863488309f36
attacker-এর কাছে কোনো উপায় নেই বাইরের hash extend করার — SECRET ছাড়া অসম্ভব।

মূল মুহূর্ত forged_tag MATCHES server recompute : True — attacker SECRET-এর একটা byte-ও না জেনে, শুধু tag আর length আন্দাজ করে, এমন একটা forged_message বানিয়ে ফেলেছে যা সার্ভারের চোখে সম্পূর্ণ বৈধ। HMAC-স্টাইল নেস্টেড hash-এ এই trick অচল, কারণ attacker-এর কাছে যা আছে তা শুধু inner hash-এর state — বাইরের toy_hash(secret + inner) চালাতে আবার SECRET লাগবে, যেটা attacker-এর কাছে কখনোই ছিল না।

নিজে বাড়ান:

1. GUESSED_SECRET_LEN ভুল হলে কী ঘটে দেখুন — attack fail করে কীভাবে, আর কেন length-brute-force বাস্তব আক্রমণের একটা প্রয়োজনীয় ধাপ
2. প্রকৃত HMAC (hmac.new(key, msg, hashlib.sha256)) দিয়ে একই attack চেষ্টা করুন — কোথায় trick ভেঙে যায় দেখান
3. toy_hash-এ যদি চূড়ান্ত ধাপে একটা “finalization” মিশ্রণ (যেমন state-কে আরেকবার আলাদা constant দিয়ে compress করা) যোগ করেন, length-extension কি তাতেও আটকায়? কেন/কেন না যুক্তি দিন (ইঙ্গিত: SHA-512/256-জাতীয় truncated variant এই কৌশলই ব্যবহার করে)