Files
mtusi2026lab2/auth.go
T

148 lines
4.3 KiB
Go

package main
import (
"context"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"net/http"
"strings"
"time"
"unicode/utf8"
"github.com/jackc/pgx/v5"
"github.com/redis/go-redis/v9"
"golang.org/x/crypto/argon2"
)
func password(body map[string]json.RawMessage) (string, error) {
var p string
if json.Unmarshal(body["password"], &p) != nil || utf8.RuneCountInString(p) < 12 || utf8.RuneCountInString(p) > 128 {
return "", invalid()
}
return p, nil
}
func hashPassword(p string) string {
salt := make([]byte, 16)
if _, err := rand.Read(salt); err != nil {
panic(err)
}
key := argon2.IDKey([]byte(p), salt, 3, 64*1024, 1, 32)
return "$argon2id$v=19$m=65536,t=3,p=1$" + base64.RawStdEncoding.EncodeToString(salt) + "$" + base64.RawStdEncoding.EncodeToString(key)
}
func verifyPassword(hash, p string) bool {
parts := strings.Split(hash, "$")
if len(parts) != 6 || parts[1] != "argon2id" || parts[2] != "v=19" || parts[3] != "m=65536,t=3,p=1" {
return false
}
salt, e := base64.RawStdEncoding.DecodeString(parts[4])
if e != nil || len(salt) != 16 {
return false
}
want, e := base64.RawStdEncoding.DecodeString(parts[5])
if e != nil || len(want) != 32 {
return false
}
actual := argon2.IDKey([]byte(p), salt, 3, 64*1024, 1, 32)
return subtle.ConstantTimeCompare(want, actual) == 1
}
func (a *App) kdfSlot(ctx context.Context) error {
select {
case a.kdf <- struct{}{}:
return nil
case <-ctx.Done():
return unavailable()
}
}
type storedSession struct {
UserID string `json:"user_id"`
ExpiresAt time.Time `json:"expires_at"`
}
func sessionKey(token string) string {
h := sha256.Sum256([]byte(token))
return "sess:" + hex.EncodeToString(h[:])
}
func (a *App) authenticate(ctx context.Context, r *http.Request) (string, string, error) {
values := r.Header.Values("Authorization")
if len(values) != 1 {
return "", "", unauthorized()
}
parts := strings.Fields(values[0])
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
return "", "", unauthorized()
}
token, e := base64.RawURLEncoding.DecodeString(parts[1])
if e != nil || len(token) != 32 {
return "", "", unauthorized()
}
key := sessionKey(parts[1])
raw, err := a.sessions.Get(ctx, key).Bytes()
if errors.Is(err, redis.Nil) {
return "", "", unauthorized()
}
if err != nil {
return "", "", unavailable()
}
var session storedSession
if json.Unmarshal(raw, &session) != nil {
return "", "", unavailable()
}
if !time.Now().Before(session.ExpiresAt) {
return "", "", unauthorized()
}
if _, err = a.user(ctx, session.UserID); err != nil {
var ae apiError
if errors.As(err, &ae) && ae.status == 404 {
return "", "", unauthorized()
}
return "", "", err
}
return session.UserID, key, nil
}
func (a *App) login(ctx context.Context, r *http.Request) (int, any, error) {
if r.ContentLength > 0 || len(r.TransferEncoding) > 0 {
return 0, nil, invalid()
}
username, p, ok := r.BasicAuth()
if len(r.Header.Values("Authorization")) != 1 || !ok || !usernamePattern.MatchString(username) || !utf8.ValidString(p) || utf8.RuneCountInString(p) < 12 || utf8.RuneCountInString(p) > 128 {
return 0, nil, unauthorized()
}
var hash string
var u User
var created time.Time
err := a.db.QueryRow(ctx, "SELECT id::text,username,display_name,created_at,password_hash FROM users WHERE username=$1", username).Scan(&u.ID, &u.Username, utf8String{&u.DisplayName}, &created, &hash)
absent := errors.Is(err, pgx.ErrNoRows)
if err != nil && !absent {
return 0, nil, unavailable()
}
if absent {
hash = a.dummyHash
}
if err = a.kdfSlot(ctx); err != nil {
return 0, nil, err
}
valid := verifyPassword(hash, p)
<-a.kdf
if !valid || absent {
return 0, nil, unauthorized()
}
u.CreatedAt = stamp(created)
tokenBytes := make([]byte, 32)
if _, err = rand.Read(tokenBytes); err != nil {
return 0, nil, unavailable()
}
token := base64.RawURLEncoding.EncodeToString(tokenBytes)
expires := time.Now().UTC().Truncate(time.Second).Add(a.ttl)
raw, _ := json.Marshal(storedSession{u.ID, expires})
if err = a.sessions.SetArgs(ctx, sessionKey(token), raw, redis.SetArgs{Mode: "NX", ExpireAt: expires}).Err(); err != nil {
return 0, nil, unavailable()
}
return 201, map[string]any{"token": token, "token_type": "Bearer", "expires_at": expires.Format(time.RFC3339), "user": u}, nil
}