Горизонтальное масштабирование за LB с общими сессиями Redis, X-Instance-Id, обязательным Idempotency-Key в PostgreSQL, сценариями failover/persistence и измерением цены масштабирования при фиксированном CPU/RAM бюджете.
111 lines
3.7 KiB
Go
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)
|
|
}
|