की डेरिवेशन फ़ंक्शन: PBKDF2, Argon2 और scrypt की तुलना

2026 में password-derived encryption keys के लिए Argon2id recommended choice है (PHC winner, OWASP की top pick, GPU और ASIC attackers के against actively defended), scrypt solid second है (memory-hard, cryptocurrencies में widely deployed), और PBKDF2-SHA-256 at 600,000+ iterations compatibility के लिए acceptable रहता है लेकिन minimal GPU resistance offer करता है। File transfer apps जहाँ users shared file protect करने के लिए password enter करते हैं, उनके लिए 3 iterations, 64 MiB memory, और 4 parallelism के साथ Argon2id modern baseline है। PBKDF2 survive करता है क्योंकि यह Web Crypto API में built-in है और कोई WASM dependency नहीं चाहता। यहाँ तीनों कैसे differ करते हैं और हर एक कब sense बनाता है।

तुलना तालिका

| Property | PBKDF2 | scrypt | Argon2id | |---|---|---|---| | Year introduced | 2000 (RFC 2898) | 2009 (RFC 7914) | 2015 (PHC winner) | | Memory-hard | नहीं | हाँ | हाँ | | Parameter flexibility | Iterations only | N, r, p | time, memory, parallelism | | GPU resistance | कमज़ोर | Moderate | Strong | | ASIC resistance | बहुत कमज़ोर | Moderate | Strong | | Browser-native (Web Crypto) | हाँ | नहीं | नहीं | | OWASP 2024 recommendation | Acceptable fallback | Acceptable | Preferred | | Typical browser cost (modern hardware) | 600,000 iter = ~500 ms | N=2^17 = ~800 ms | 3 iter, 64 MiB = ~1 s |

Memory-Hard क्यों Matter करता है

Password-based encryption का threat model है offline brute force। Attacker ciphertext plus salt grab करता है, password dictionary से run करता है, और एक ऐसी key derive करने की कोशिश करता है जो successfully decrypt हो। Defense है हर attempt को expensive बनाना।

PBKDF2 हर attempt को सिर्फ CPU time (SHA-256 iterations) में expensive बनाता है। Modern GPUs billions of SHA-256 operations per second run करते हैं; एक gaming GPU प्रतिदिन 10-100 million PBKDF2-SHA-256-600000 guesses test कर सकता है। ASIC attackers orders of magnitude better करते हैं।

Memory-hard functions (scrypt, Argon2) per attempt एक fixed amount of memory require करते हैं। GPUs और ASICs के पास limited memory bandwidth है, इसलिए per-device parallelism bounded है। 64 MiB memory requirement का मतलब 16 GB VRAM वाला GPU अधिकतम 256 parallel guesses run कर सकता है, लाखों नहीं। Brute force की economic cost 2-3 orders of magnitude बढ़ जाती है।

PBKDF2: Legacy Default

PBKDF2 (RFC 2898) एक pseudorandom function — typically HMAC-SHA-256 या HMAC-SHA-512 — को password और salt के ऊपर iterate करता है। Iteration count ही एकमात्र tunable है।

const passwordKey = await crypto.subtle.importKey(
  "raw", new TextEncoder().encode(password),
  "PBKDF2", false, ["deriveKey"]
);
const aesKey = await crypto.subtle.deriveKey(
  {
    name: "PBKDF2",
    salt,  // 16 random bytes
    iterations: 600000,
    hash: "SHA-256",
  },
  passwordKey,
  { name: "AES-GCM", length: 256 },
  false,
  ["encrypt", "decrypt"]
);

OWASP 2023 minimum 600,000 iterations of PBKDF2-SHA-256 recommend करता है। NIST SP 800-132 पुराना और कम specific है। कुछ specs (जैसे LastPass का 2018 में 100,100 का default) 2026 में बहुत कम माने जाते हैं।

Advantages: Web Crypto में built-in, कोई WASM नहीं, FIPS-validated, TLS 1.3 session resumption में supported, Node और browsers में identically काम करता है।

Limitations: कोई memory hardness नहीं, GPU और ASIC acceleration के against vulnerable। Iterations double करने से attacker cost double होती है लेकिन legitimate user cost भी। किसी point पर legitimate users wait करने से मना कर देते हैं और आप iterations cap करते हैं।

scrypt: पहली Memory-Hard Deployment

scrypt (RFC 7914) Colin Percival ने 2009 में Tarsnap के लिए invent किया था। यह password material को एक large memory buffer से mix करता है, attacker को हर guess के दौरान वह buffer hold करने के लिए force करता है।

तीन parameters:

• N: cost factor (typically 2^14 से 2^20)। Memory use roughly 128 * N * r bytes है।
• r: block size (typically 8)। Memory और GHASH iteration count दोनों affect करता है।
• p: parallelization (typically 1)। Higher values legitimate computation speed करते हैं लेकिन attackers को भी; आमतौर पर 1 पर छोड़ें।

OWASP N=2^17, r=8, p=1 को baseline recommend करता है, जो ~128 MiB consume करता है और modern hardware पर ~800 ms में run करता है।

scrypt Web Crypto API में नहीं है। JavaScript में, scrypt-js, @noble/hashes, या libsodium.js इस्तेमाल करें। Litecoin और Dogecoin scrypt को अपने proof-of-work के रूप में इस्तेमाल करते हैं, जिसने specifically scrypt के लिए ASIC development को incentivize किया, ASICs के against इसके original asymmetric advantage को कुछ हद तक erode करते हुए।

Argon2id: 2026 का Default

Argon2 ने 2015 में Password Hashing Competition जीती। तीन variants: Argon2d (fastest, data-dependent, side-channel vulnerable), Argon2i (data-independent, slower), Argon2id (hybrid, अधिकांश use के लिए recommended)। RFC 9106 ने इसे 2021 में standardize किया।

तीन parameters:

• t (time): memory के ज़रिए iterations। Typical 2-3।
• m (memory): memory in KiB। Typical 65536 (64 MiB) या higher।
• p (parallelism): degree of parallelism। Typical 1-4।

OWASP 2024 baseline: minimum के लिए t=2, m=19456 (19 MiB), p=1, और stronger protection के लिए t=3, m=65536 (64 MiB), p=4।

import { argon2id } from '@noble/hashes/argon2';
import { utf8ToBytes } from '@noble/hashes/utils';

const derivedKey = argon2id(utf8ToBytes(password), salt, {
  t: 3, m: 65536, p: 4, dkLen: 32
});

या argon2-browser (WASM) के ज़रिए:

import argon2 from 'argon2-browser';
const hash = await argon2.hash({
  pass: password, salt,
  type: argon2.ArgonType.Argon2id,
  time: 3, mem: 65536, parallelism: 4, hashLen: 32
});

Argon2id scrypt से GPU attackers को ज़्यादा effectively defeat करता है क्योंकि इसका memory access pattern bulk memory designs के लिए कम amenable है। Argon2 के लिए ASICs research में exist करते हैं लेकिन अभी attacker scale पर economically deployed नहीं हैं।

अपने App के लिए Parameters चुनना

Calibration method: वह longest wait choose करें जो आपके users tolerate करें (usually 500 ms से 2 seconds), slowest target device पर measure करें, और उस budget को hit करने के लिए parameters set करें।

HexaTransfer-style password-protected file shares के लिए, जहाँ derivation upload पर एक बार और download पर एक बार होती है, 1-2 seconds acceptable है। Parameters:

• PBKDF2-SHA-256: 600,000-1,200,000 iterations
• scrypt: N=2^17, r=8, p=1
• Argon2id: t=3, m=65536, p=4

Login systems के लिए जहाँ user password type करने के बाद wait करता है, 300-500 ms UX ceiling है। Parameters roughly half हो जाते हैं। Batch scenarios के लिए जहाँ user wait नहीं करता (जैसे background re-encryption), 3-5 seconds तक crank up करें।

Salt Management

तीनों KDFs को salt चाहिए। Rules:

• Minimum 16 random bytes
• crypto.getRandomValues() से generated, कभी Math.random() नहीं
• Per password unique (अगर Alice और Bob एक ही password use करें, उनके salts differ होने चाहिए ताकि derived keys differ हों)
• Secret नहीं — ciphertext के साथ store करें

Pepper (सभी derivations में added एक secret) कभी-कभी discuss होता है। File transfer के लिए जहाँ "server" एक dumb blob store है, pepper कोई value add नहीं करता। Account-based systems के लिए, password database से separately stored server-side pepper database dumps को attackers के लिए कम useful बनाता है।

KDFs के बीच Migration

अगर existing deployment PBKDF2 पर है और Argon2id पर move करना चाहते हैं:

• Ciphertext metadata में KDF identifier store करें ("kdf": "pbkdf2-sha256-600000" या "kdf": "argon2id-3-65536-4")
• New uploads पर, Argon2id इस्तेमाल करें
• Decrypt पर, KDF identifier read करें और matching function इस्तेमाल करें
• पुराने ciphertexts blindly upgrade कभी न करें; आपको re-derive के लिए password चाहिए

LastPass, 1Password, और Bitwarden सभी इस migration से गुज़रे हैं। तीनों अब 600,000+ iterations पर PBKDF2 default करते हैं, newer versions में Argon2id available है। हाँ, password managers भी Argon2 पर slow थे — ecosystem tooling mature होने में time लगा।

bcrypt के बारे में

bcrypt (1999) modest memory hardness के साथ एक fine password-hashing function है। यह input को 72 bytes पर cap करता है (एक famous footgun — long passwords silently truncate होते हैं)। यह Ruby on Rails और कई PHP frameworks में historical default है। 2026 में नए code के लिए, Argon2id prefer करें; bcrypt existing systems maintain करने के लिए ठीक है।

व्यावहारिक Recommendation

2026 में एक नई file transfer service के लिए:

• अगर आप 15-200 KB dependency ship कर सकते हैं: @noble/hashes या libsodium.js के ज़रिए Argon2id
• अगर zero dependencies और bundle-size-at-all-costs चाहिए: Web Crypto के ज़रिए 600,000 iterations पर PBKDF2-SHA-256
• अगर cryptocurrency wallet या कुछ legacy scrypt inherit कर रहे हैं: N=2^17 पर scrypt

Sensitive files handle करने वाले production apps के लिए, Argon2id WASM dependency के लायक है। Simple password-protected shares के लिए जहाँ users वैसे भी random password generate करते हैं, PBKDF2 adequate है क्योंकि entropy password में है, KDF में नहीं।

hexatransfer.com पर आज़माएं — मुफ्त, बिना अकाउंट, 10 GB तक।