111 lines
3.6 KiB
Go
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
|
|
}
|