Hashing sandi

Sandi tidak pernah disimpan, tidak pernah dienkripsi, dan tidak pernah di-hash dengan SHA-256. Yang dipakai adalah fungsi yang sengaja lambat — dan seberapa lambat adalah keputusan yang harus kamu ambil sadar.

bcrypt

import "golang.org/x/crypto/bcrypt"

func HashSandi(sandi string) (string, error) {
	if len(sandi) > 72 {
		return "", ErrSandiTerlaluPanjang   // bcrypt memotong diam-diam
	}
	b, err := bcrypt.GenerateFromPassword([]byte(sandi), 12)   // biaya 12
	if err != nil {
		return "", fmt.Errorf("hash sandi: %w", err)
	}
	return string(b), nil
}

func PeriksaSandi(hash, sandi string) bool {
	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(sandi)) == nil
}

$2a$12$N9qo8uLOickgx2ZMRZoMye.IjPeCLQK6IbnCtHwHz7Kk8vY7Zg9Wm
│  │  │                      │
│  │  └─ salt (22 karakter)  └─ hash
│  └──── biaya (2^12 iterasi)
└─────── varian algoritma

Memilih biaya

Argon2id

import "golang.org/x/crypto/argon2"

type ParamArgon struct {
	Waktu   uint32   // iterasi
	Memori  uint32   // KiB
	Thread  uint8
	Panjang uint32
}

var argonBaku = ParamArgon{Waktu: 2, Memori: 64 * 1024, Thread: 4, Panjang: 32}

func HashArgon(sandi string) (string, error) {
	salt := make([]byte, 16)
	if _, err := rand.Read(salt); err != nil {   // crypto/rand, BUKAN math/rand
		return "", err
	}

	h := argon2.IDKey([]byte(sandi), salt,
		argonBaku.Waktu, argonBaku.Memori, argonBaku.Thread, argonBaku.Panjang)

	// Simpan parameternya bersama hash: tanpa itu, menaikkan
	// parameter nanti akan mematahkan semua sandi lama.
	return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s",
		argonBaku.Memori, argonBaku.Waktu, argonBaku.Thread,
		base64.RawStdEncoding.EncodeToString(salt),
		base64.RawStdEncoding.EncodeToString(h)), nil
}

Login yang tidak membocorkan apa pun

// Hash palsu berbiaya sama, dipakai saat penggunanya tidak ada.
var hashUmpan, _ = bcrypt.GenerateFromPassword([]byte("umpan"), 12)

func (s *Layanan) Masuk(ctx context.Context, email, sandi string) (Pengguna, error) {
	u, err := s.simpan.DariEmail(ctx, email)
	if errors.Is(err, ErrTidakDitemukan) {
		// Tetap jalankan hashing supaya waktu responsnya sama —
		// tanpa ini, penyerang bisa menebak email mana yang terdaftar
		// hanya dengan mengukur waktu balasan.
		_ = bcrypt.CompareHashAndPassword(hashUmpan, []byte(sandi))
		return Pengguna{}, ErrKredensialSalah
	}
	if err != nil {
		return Pengguna{}, err
	}

	if !PeriksaSandi(u.Hash, sandi) {
		return Pengguna{}, ErrKredensialSalah   // pesan yang SAMA
	}
	return u, nil
}

Menaikkan biaya tanpa mengganggu pengguna

func (s *Layanan) Masuk(...) (Pengguna, error) {
	...
	if !PeriksaSandi(u.Hash, sandi) {
		return Pengguna{}, ErrKredensialSalah
	}

	// Sandinya benar — dan hanya di sini kita punya sandi polosnya.
	// Kalau hash lama memakai biaya rendah, hash ulang sekarang.
	if biaya, err := bcrypt.Cost([]byte(u.Hash)); err == nil && biaya < 12 {
		if baru, err := HashSandi(sandi); err == nil {
			_ = s.simpan.PerbaruiHash(ctx, u.ID, baru)
		}
	}
	return u, nil
}

Aturan sandi yang benar-benar berguna

1. Minimal 8 karakter — dan jangan batasi maksimumnya di bawah 64.
2. Jangan wajibkan campuran karakter. Ia menghasilkan Password1!, bukan sandi kuat.
3. Tolak sandi yang sudah bocor — periksa terhadap daftar sandi umum saat pendaftaran.
4. Izinkan tempel dan pengelola sandi. Menonaktifkannya membuat orang memakai sandi lebih lemah.
5. Jangan wajibkan penggantian berkala tanpa indikasi kebocoran; ia menghasilkan sandi yang lebih buruk.
6. Tawarkan 2FA untuk akun yang menyentuh uang atau data pribadi.