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 }