Files
mtusi2026lab3/internal/auth/password.go
T
Mlvn b1972bcfd8 Реализовать lab3: HAProxy, API×N, идемпотентность и трек 1.
Горизонтальное масштабирование за LB с общими сессиями Redis, X-Instance-Id,
обязательным Idempotency-Key в PostgreSQL, сценариями failover/persistence и
измерением цены масштабирования при фиксированном CPU/RAM бюджете.
2026-11-06 21:07:00 +03:00

111 lines
3.7 KiB
Go

// Package auth хранит пароли через Argon2id.
//
// bcrypt отвергнут: библиотека молча режет пароль на 72 байта, а контракт
// разрешает до 128 Unicode code points, включая символы вне ASCII.
// Argon2id принимает пароль целиком. Параметры — интерактивные, не «серверные»
// на сотни миллисекунд: smoke создаёт несколько пользователей подряд.
package auth
import (
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
const (
argonTime = 2
argonMemory = 19 * 1024 // KiB, около 19 MiB
argonThreads = 1
argonKeyLen = 32
argonSaltLen = 16
)
// Hasher умеет хешировать и проверять. dummy — хеш случайного пароля,
// чтобы отсутствующий username занимал примерно столько же CPU, сколько неверный пароль.
type Hasher struct {
dummy string
}
// NewHasher готовит dummy-хеш один раз на процесс.
func NewHasher() (*Hasher, error) {
dummy, err := Hash(randomPassword())
if err != nil {
return nil, err
}
return &Hasher{dummy: dummy}, nil
}
// Hash возвращает PHC-строку. Её пишем в users.password_hash.
func Hash(password string) (string, error) {
salt := make([]byte, argonSaltLen)
if _, err := rand.Read(salt); err != nil {
return "", err
}
sum := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s",
argonMemory, argonTime, argonThreads,
base64.RawStdEncoding.EncodeToString(salt),
base64.RawStdEncoding.EncodeToString(sum),
), nil
}
// Verify сравнивает пароль с PHC-строкой. При битой строке возвращает false, не панику.
func (h *Hasher) Verify(encoded, password string) bool {
if encoded == "" {
encoded = h.dummy
}
ok, err := verify(encoded, password)
if err != nil {
// Всё равно тратим время dummy-проверки, чтобы ветка ошибки не была мгновенной.
_, _ = verify(h.dummy, password)
return false
}
return ok
}
// Burn тратит время проверки, когда пользователя нет. Результат всегда false.
func (h *Hasher) Burn(password string) {
_, _ = verify(h.dummy, password)
}
func verify(encoded, password string) (bool, error) {
parts := strings.Split(encoded, "$")
// ["", "argon2id", "v=19", "m=..,t=..,p=..", salt, hash]
if len(parts) != 6 || parts[1] != "argon2id" || parts[2] != "v=19" {
return false, fmt.Errorf("bad hash")
}
var memory uint32
var timeCost uint32
var threads uint8
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil {
return false, err
}
if memory != argonMemory || timeCost != argonTime || threads != argonThreads {
return false, fmt.Errorf("unexpected argon2 parameters")
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil {
return false, err
}
want, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil {
return false, err
}
got := argon2.IDKey([]byte(password), salt, timeCost, memory, threads, uint32(len(want)))
// ConstantTimeCompare не даёт выйти на первом несовпавшем байте.
if subtle.ConstantTimeCompare(got, want) != 1 {
return false, nil
}
return true, nil
}
func randomPassword() string {
buf := make([]byte, 24)
_, _ = rand.Read(buf)
return base64.RawStdEncoding.EncodeToString(buf)
}