package main import ( "context" "crypto/rand" "crypto/sha256" "encoding/base64" "net/http" "regexp" "strings" "unicode/utf8" "github.com/alexedwards/argon2id" ) // Argon2id (RFC 9106, профиль «низкая память»: t=3, m=64 MiB). Параметры хранятся внутри PHC-строки хеша, // поэтому их можно менять без инвалидации старых паролей. var argonParams = &argon2id.Params{Memory: 64 * 1024, Iterations: 3, Parallelism: 2, SaltLength: 16, KeyLength: 32} var tokenPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{32,256}$`) // Hasher ограничивает число одновременных хеширований: каждое занимает 64 MiB памяти. type Hasher struct { sem chan struct{} dummy string // хеш-«пустышка»: вход несуществующего пользователя стоит столько же времени, сколько неверный пароль } func newHasher(concurrency int) *Hasher { h := &Hasher{sem: make(chan struct{}, concurrency)} dummy, err := argon2id.CreateHash("dummy-password-for-timing-equalization", argonParams) if err != nil { panic(err) } h.dummy = dummy return h } func (h *Hasher) acquire(ctx context.Context) error { select { case h.sem <- struct{}{}: return nil case <-ctx.Done(): return ctx.Err() } } func (h *Hasher) release() { <-h.sem } func (h *Hasher) hash(ctx context.Context, password string) (string, error) { if err := h.acquire(ctx); err != nil { return "", err } defer h.release() return argon2id.CreateHash(password, argonParams) } func (h *Hasher) verify(ctx context.Context, password, hash string) (bool, error) { if err := h.acquire(ctx); err != nil { return false, err } defer h.release() return argon2id.ComparePasswordAndHash(password, hash) // сравнение за постоянное время } // newToken: 32 байта из crypto/rand (256 бит), клиенту — base64url (43 символа), в БД — только SHA-256. func newToken() (token string, hash []byte) { raw := make([]byte, 32) if _, err := rand.Read(raw); err != nil { panic("crypto/rand failed") } token = base64.RawURLEncoding.EncodeToString(raw) return token, hashToken(token) } func hashToken(token string) []byte { sum := sha256.Sum256([]byte(token)) return sum[:] } // splitAuthorization разбирает «Scheme value»; схема нечувствительна к регистру (RFC 9110). func splitAuthorization(r *http.Request) (scheme, value string) { header := r.Header.Get("Authorization") scheme, value, ok := strings.Cut(header, " ") if !ok { return "", "" } return strings.ToLower(scheme), strings.TrimSpace(value) } // parseBasic: base64(username:password), UTF-8. Двоеточие допустимо в пароле, но не в username. func parseBasic(r *http.Request) (username, password string, ok bool) { scheme, value := splitAuthorization(r) if scheme != "basic" || value == "" { return "", "", false } decoded, err := base64.StdEncoding.DecodeString(value) if err != nil || len(decoded) > 1024 || !utf8.Valid(decoded) { return "", "", false } username, password, ok = strings.Cut(string(decoded), ":") return username, password, ok } // bearerToken возвращает токен только из «Authorization: Bearer …». X-User-Id и Basic игнорируются. func bearerToken(r *http.Request) (string, bool) { scheme, value := splitAuthorization(r) if scheme != "bearer" || !tokenPattern.MatchString(value) { return "", false } return value, true }