Password Storage — Salt, ধীর KDF, আর Rainbow Table-এর বিরুদ্ধে যুদ্ধ

লক্ষ্য: একটা production-realistic password-storage module বানানো — শুধু hash করা না, বরং salt (automatic), pepper (manual, আলাদা secret), tunable cost, আর secret-তুলনার timing-safety — এই চারটা সিদ্ধান্তই একসাথে কাজ করছে তা প্রমাণ করা।

# password_store.py -- bcrypt + pepper + tunable cost + constant-time compare
import bcrypt, hmac, time

PEPPER = b"app-wide-secret-not-in-db-2026"  # env var / secrets manager -- NEVER in the database

def hash_password(password: str, pepper: bytes = PEPPER, cost: int = 12) -> bytes:
    peppered = password.encode() + pepper
    return bcrypt.hashpw(peppered, bcrypt.gensalt(rounds=cost))  # bcrypt নিজেই salt বসায়, embed করে

def verify_password(password: str, stored_hash: bytes, pepper: bytes = PEPPER) -> bool:
    peppered = password.encode() + pepper
    return bcrypt.checkpw(peppered, stored_hash)

# ---------- ধাপ ১-২: একই password দুইবার hash -> bcrypt নিজেই আলাদা salt বসায় ----------
pw = "correct horse battery staple"
h1, h2 = hash_password(pw), hash_password(pw)
print(f"hash #1: {h1.decode()}")
print(f"hash #2: {h2.decode()}")
print(f"h1 == h2 ? {h1 == h2}   (bcrypt নিজেই random salt বসায় -- একই password, ভিন্ন stored bytes)")
print(f"verify_password(pw, h1) = {verify_password(pw, h1)}")
print(f"verify_password(pw, h2) = {verify_password(pw, h2)}")
print()

# ---------- ধাপ ৩: pepper -- শুধু DB leak হলে সেটা যথেষ্ট না ----------
stolen_hash = hash_password("hunter2")
match_no_pepper = bcrypt.checkpw(b"hunter2", stolen_hash)
match_with_pepper = verify_password("hunter2", stolen_hash)
print(f"শুধু DB চুরি, সঠিক password কিন্তু pepper ছাড়া: match = {match_no_pepper}")
print(f"একই password, সঠিক pepper সহ (app secret)     : match = {match_with_pepper}")
print()

# ---------- ধাপ ৪: work factor -- cost বাড়ালে সময় কতটা বাড়ে ----------
for cost in (10, 12, 14):
    t0 = time.perf_counter()
    hash_password(pw, cost=cost)
    dt = time.perf_counter() - t0
    print(f"bcrypt cost={cost}: {dt*1000:.1f} ms/hash")
print()

# ---------- ধাপ ৫: constant-time comparison ----------
def naive_compare(a: bytes, b: bytes) -> bool:
    if len(a) != len(b):
        return False
    for x, y in zip(a, b):      # early-exit byte-loop -- ঠিক এই প্যাটার্নটাই ঐতিহাসিক bug-এর উৎস
        if x != y:
            return False
    return True

TOKEN = h1[7:39]  # ৩২-byte token ধরে নেওয়া হলো (bcrypt hash থেকে কাটা)

def timed(fn, guess, trials=200_000):
    t0 = time.perf_counter()
    for _ in range(trials):
        fn(TOKEN, guess)
    return (time.perf_counter() - t0) / trials * 1e9

early = b"X" + TOKEN[1:]
late = TOKEN[:-1] + b"X"

t_naive_e, t_naive_l = timed(naive_compare, early), timed(naive_compare, late)
t_eq_e, t_eq_l = timed(lambda a, b: a == b, early), timed(lambda a, b: a == b, late)
t_safe_e, t_safe_l = timed(hmac.compare_digest, early), timed(hmac.compare_digest, late)

print(f"হাতে-লেখা early-exit loop : early-mismatch {t_naive_e:.1f} ns, late-mismatch {t_naive_l:.1f} ns, "
      f"ratio {t_naive_l/t_naive_e:.2f}x")
print(f"Python-এর নিজস্ব bytes ==  : early-mismatch {t_eq_e:.1f} ns, late-mismatch {t_eq_l:.1f} ns, "
      f"ratio {t_eq_l/t_eq_e:.2f}x")
print(f"hmac.compare_digest        : early-mismatch {t_safe_e:.1f} ns, late-mismatch {t_safe_l:.1f} ns, "
      f"ratio {t_safe_l/t_safe_e:.2f}x")

প্রত্যাশিত output (bcrypt নিজে random salt generate করে বলে hash-এর exact byte প্রতিবার আলাদা হবে — নিচের bcrypt-hash-string দুইটা তাই শুধু গঠন/প্যাটার্নের প্রতিনিধি; boolean আর timing ফলাফল সবসময় একই প্যাটার্নে আসবে):

hash #1: $2b$12$GU4rE2YqWnjsGFGfCNcwvOZ08iNIGjRwsy8Yzjh0aY1SYOPE3McL6
hash #2: $2b$12$VmBd1JO47drRMlN.2EShAO95qw6jnBxCyrarIrFHyZhJ5VxjDhEEG
h1 == h2 ? False   (bcrypt নিজেই random salt বসায় -- একই password, ভিন্ন stored bytes)
verify_password(pw, h1) = True
verify_password(pw, h2) = True

শুধু DB চুরি, সঠিক password কিন্তু pepper ছাড়া: match = False
একই password, সঠিক pepper সহ (app secret)     : match = True

bcrypt cost=10: 74.7 ms/hash
bcrypt cost=12: 293.0 ms/hash
bcrypt cost=14: 1144.2 ms/hash

হাতে-লেখা early-exit loop : early-mismatch 567.9 ns, late-mismatch 2911.8 ns, ratio 5.13x
Python-এর নিজস্ব bytes ==  : early-mismatch 170.2 ns, late-mismatch 184.9 ns, ratio 1.09x
hmac.compare_digest        : early-mismatch 120.4 ns, late-mismatch 118.1 ns, ratio 0.98x

তিনটা মুহূর্ত এখানে গুরুত্বপূর্ণ। এক, h1 == h2 হলো False অথচ দুইটাই একই password-এর জন্য verify_password দিয়ে True — কারণ bcrypt-এর নিজের salt hash-string-এর ভেতরেই embedded ($2b$12$ এর পরের অংশে), verify করার সময় সেই salt বের করে আবার একই গণনা করা হয়। দুই, cost 10→12→14 প্রায় প্রতিবার সময় দ্বিগুণ-চারগুণ করে দিচ্ছে (10-এ ৭৪.৭ms, 14-এ ১১৪৪.২ms) — এটাই “tunable work factor”-এর ব্যবহারিক অর্থ: হার্ডওয়্যার দ্রুত হলে শুধু একটা সংখ্যা বাড়িয়ে দিলেই একই primitive বছরের পর বছর টিকে থাকে। তিন, হাতে-লেখা early-exit loop-এ late-mismatch, early-mismatch-এর চেয়ে ৫.১৩ গুণ বেশি সময় নিয়েছে — একটা স্পষ্ট timing side-channel। কিন্তু লক্ষ্য করুন — Python-এর নিজস্ব built-in bytes == অপারেটরে এই পার্থক্য প্রায় অদৃশ্য (1.09x)। কারণ কী? CPython-এর bytes.__eq__ C-level-এ implemented, আর ৩২ byte-এর জন্য C-level early-exit-এর সময়-পার্থক্য এত ছোট যে Python function-call-এর নিজস্ব overhead-এর নিচে চাপা পড়ে যায় — এই নির্দিষ্ট microbenchmark-এ signal পাওয়া যায়নি, যদিও hmac.compare_digest-ও প্রায় একই মাত্রার (0.98x) constant-time ফলাফল দিচ্ছে।

নিজে বাড়ান:

1. PEPPER-কে ফাংশনের ডিফল্ট প্যারামিটার হিসেবে না রেখে module-level কনস্ট্যান্ট বানালে কী সুবিধা/অসুবিধা হয়? Pepper rotate করতে হলে (leak সন্দেহ হলে) এই ডিজাইনে কী সমস্যা হবে?
2. bcrypt.checkpw নিজেই ভেতরে constant-time comparison ব্যবহার করে কিনা যাচাই করুন (bcrypt লাইব্রেরির source/docs দেখে) — আর কেন এটা password-verification-এর জন্য একটা অলিখিত requirement
3. Argon2id-এ migrate করলে hash_password/verify_password-এর সিগনেচার কী বদলাবে? argon2.PasswordHasher দিয়ে পুরো module আবার লিখুন, আর bcrypt-versioned hash আর Argon2-versioned hash — দুইটাই একই DB column-এ থাকলে verify করার সময় কীভাবে চিনবেন কোনটা কোন KDF দিয়ে বানানো (ইঙ্গিত: bcrypt hash-string $2b$ দিয়ে শুরু হয়, Argon2 hash-string $argon2id$ দিয়ে — নিজেই self-describing)