Your LLM writes the code. VibeGuard rights its instincts.

---
id: auth/password-hashing
status: stable
tags: [auth, passwords, kdf]
---

# Principles

- Never store plaintext. Never.
- Never use general–purpose hashes (MD5, SHA–1, SHA–256) for passwords.
- Use a memory–hard KDF: Argon2id (preferred), scrypt, or bcrypt.
- Tune parameters for the hardware you deploy on — target ~250–500ms per hash.
- Always include a per–password random salt. The KDF handles this for you.
- Rehash on verify when parameters have changed.
- Constant–time compare. Always.
- Never log the input or the hash.

## Why a KDF, not a hash?

Fast hashes are the point of a hash. Password storage wants the opposite —
something slow and expensive per–attempt, so that a leaked database is not
the same as a leaked password list.

## What VibeGuard will NOT tell you

- Which library is allowed in your org. That’s policy.
- The exact parameters for your hardware. Benchmark on the real box.

---
language: python
libraries: [argon2-cffi]
updated: 2026-03-14
---

# Library choice

Use argon2-cffi directly. It wraps the reference C implementation
and exposes PasswordHasher with sensible defaults.

## Reference implementation

from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError

ph = PasswordHasher(
    time_cost=3,
    memory_cost=64 * 1024,   # 64 MiB
    parallelism=4,
)

def hash_password(pw: str) -> str:
    return ph.hash(pw)

def verify_password(pw: str, stored: str) -> bool:
    try:
        ph.verify(stored, pw)
    except VerifyMismatchError:
        return False
    return True

## Gotchas

- VerifyMismatchError is the only non–exceptional miss — catch it narrowly.
- check_needs_rehash lets you re–tune parameters without a password reset.

## Tests to write

- hash → verify round–trip
- verify rejects the wrong password
- two hashes of the same password differ (salted)
- rehash fires after a parameter bump

---
language: csharp
libraries: [Konscious.Security.Cryptography.Argon2]
updated: 2026-03-14
---

# Library choice

Use Konscious.Security.Cryptography.Argon2 — the actively
maintained Argon2id in managed C#. Don’t use PasswordHasher<T>
from ASP.NET Identity for new code — it’s PBKDF2 under the hood.

## Reference implementation

using Konscious.Security.Cryptography;
using System.Security.Cryptography;
using System.Text;

public static class Passwords
{
    public static (string Hash, byte[] Salt) Hash(string password)
    {
        var salt = RandomNumberGenerator.GetBytes(16);
        using var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password))
        {
            Salt                = salt,
            DegreeOfParallelism = 4,
            MemorySize          = 65536,   // 64 MiB
            Iterations          = 3,
        };
        var hash = argon2.GetBytes(32);
        return (Convert.ToBase64String(hash), salt);
    }
}

## Gotchas

- Always UTF8.GetBytes the password, never Encoding.Default.
- Store the salt alongside the hash; 16 bytes is the minimum.
- using on Argon2id scrubs the managed buffer when done.

---
id: architecture/threat-modeling
status: stable
applies_to: [all]
---

# Principles

- Start with a data–flow diagram. Mark every trust boundary.
- Apply STRIDE to every element: Spoofing, Tampering, Repudiation,
  Information disclosure, Denial of service, Elevation of privilege.
- Rank threats by risk (likelihood × impact), not by ease of fix.
- Every threat gets a disposition: mitigate, accept, transfer, or eliminate.
- Mitigations map to specific controls, not hand–waving.
- Minimize attack surface — the most effective mitigation is removal.
- Review the model in code review. New data flow? Update the model.
- Assume breach — model what happens after a component is compromised.

## Why before code?

Security controls applied by intuition cluster around what the developer
thought of and leave blind spots everywhere else. A threat model is the
systematic alternative — it finds the threats you would not have
guessed by walking the architecture before the code exists.

## What VibeGuard will NOT tell you

- Your specific threat actors. That’s your threat intelligence.
- Your risk appetite. That’s a business decision.