கடwords எவ்வாறு பாதுகாப்பாக சேமிக்கப்பட வேண்டும் மற்றும் கையாளப்பட வேண்டும்?

Question

Accepted Answer

Passwords வெளிப்படையாக சேமிக்கப்பட வேண்டாது — **plaintext இல் ஒருபோதும் இல்லை**, ஆனால் **hashed** வலிமையான, மெதுவான, salted password-hashing algorithm (bcrypt, Argon2, scrypt) உடன். சரியான password handling மிகவும் முக்கியமானது ஏனெனில் password breaches மிகவும் நுண்ணிய மற்றும் பொதுவான.

## Plaintext ஐ சேமிக்க வேண்டாம்; சரியாக hash செய்யவும்

```text
❌ NEVER store passwords in plaintext (a breach exposes all passwords directly)
❌ Don't use fast/general hashes (MD5, SHA-256) alone — too fast → easily brute-forced
✅ HASH with a dedicated PASSWORD HASHING algorithm: BCRYPT, ARGON2, or scrypt:
  → SLOW by design (resistant to brute-force/GPU cracking)
  → SALTED (a unique random salt per password) → prevents rainbow-table attacks and
    identical passwords hashing the same
```

```js
// hashing with bcrypt (handles salting automatically)
const hash = await bcrypt.hash(password, 12);   // store the hash (with salt + cost)
// verifying at login
const valid = await bcrypt.compare(inputPassword, storedHash);   // compare securely
```

## இந்த algorithms ஏன்

```text
SALT → unique random value per password → identical passwords get DIFFERENT hashes;
  defeats precomputed (rainbow table) attacks
SLOW (work factor) → deliberately expensive to compute → brute-forcing millions of
  guesses becomes impractical (tunable cost factor as hardware improves)
→ bcrypt/Argon2/scrypt are designed for passwords; general hashes (SHA) are NOT.
```

## மற்ற password practices

```text
✓ Enforce reasonable strength (length over complexity); check against breached-password lists
✓ MULTI-FACTOR authentication (MFA) → strong protection even if a password leaks
✓ HTTPS for transmission; rate-limit / lock out brute-force login attempts
✓ Secure password RESET (time-limited tokens); never email passwords; never log them
```

## இது ஏன் முக்கியமானது

Secure password storage மற்றும் handling ஐ புரிந்துகொள்வது அத்யாவசியமானது ஏனெனில் **password breaches மிகவும் பொதுவான மற்றும் நுண்ணிய**, மற்றும் முறையற்ற password storage ஒரு தீவிரமான, அடிக்கடி ஏற்படும் vulnerability, எனவே இது must-know security knowledge.

Molecular rules மிகவும் முக்கியமானது: **passwords ஐ plaintext இல் சேமிக்க வேண்டாம்** (ஒரு breach ஒவ்வொரு user இன் password ஐ நேரடியாக expose செய்யும் — பேரழிவு), மற்றும் **fast general hashes (MD5, SHA-256) ஐ நம்ப வேண்டாம்** அவை மிக வேகமாக இருக்கின்றன மற்றும் எளிதாக brute-forced ஆக இருக்கின்றன.

இதற்கு பதிலாக, **dedicated password-hashing algorithms (bcrypt, Argon2, scrypt) உடன் hash செய்யவும்** அவை **slow by design** (brute-force மற்றும் GPU cracking க்கு resistant) மற்றும் **salted** (ஒவ்வொரு password க்கும் ஒரு unique random salt, precomputed attacks களை தடுக்கிறது மற்றும் identical passwords வெவ்வேறு hashes பெறவைக்கிறது).

আপনি **why these algorithms** ஐ புரிந்துகொண்டால் — salting (precomputed attacks ஐ தோற்கடிக்கும், identical passwords வெவ்வேறு hash களை செய்யும்) மற்றும் slowness/work factor (mass brute-forcing ஐ impractical செய்யும், tunable cost உடன் hardware தேறிய போது) — என்பது சரியான approach versus பொதுவான mistakes (plaintext, fast hashes, no salt) ஐ விளக்குகிறது.

**மற்ற practices** ஐ புரிந்துகொண்டால் — reasonable strength ஐ enforce செய்யும் (length over complexity, breached-password lists ஐ check செய்யும்), **MFA** (strong protection password leak ஆனாலும்), HTTPS transmission க்கு, rate-limiting login attempts, secure password reset (time-limited tokens), மற்றும் passwords ஐ ஒருபோதும் log அல்லது email செய்ய வேண்டாம் — comprehensive password security ஐ பிரதிபலிக்கிறது.

Password handling என்பது high-stakes area தான் mistakes (plaintext storage, weak hashing) நேரடியாக major breaches ஐ ஏற்படுத்தும், சரியான handling (strong salted hashing, MFA) users ஐ கணிசமாக பாதுகாக்கிறது.

Password breaches பொதுவான மற்றும் நுண்ணிய மற்றும் முறையற்ற storage தீவிரமான, அடிக்கடி vulnerability, மற்றும் secure storage ஐ (plaintext ஒருபோதும் இல்லை, bcrypt/Argon2 உடன் strong salted slow hashing) மற்றும் good practices (MFA, rate-limiting) ஐ புரிந்துகொள்வது essential users ஐ பாதுகாக்க, secure password storage மற்றும் handling ஐ புரிந்துகொள்வது essential, must-know security knowledge — critical, high-stakes area தான் சரியான approach (dedicated password hashing, salting, MFA) catastrophic password breaches ஐ தடுக்கிறது முறையற்ற handling ஐ ஏற்படுத்தும், fundamental knowledge authentication ஐ handle செய்யும் எந்த developer க்கும்.