Files
mtusi2026lab3/auth.go
T

111 lines
3.6 KiB
Go

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
}