148 lines
4.3 KiB
Go
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
|
|
}
|