Files
mtusi2026lab3/internal/handler/user.go
T

157 lines
3.4 KiB
Go

package handler
import (
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"errors"
"net/http"
"regexp"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"golang.org/x/crypto/argon2"
"mtusi2026lab2/internal/middleware"
"mtusi2026lab2/internal/model"
"mtusi2026lab2/internal/storage"
)
var usernameRegexp = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
type UserHandler struct {
store *storage.AuthStore
}
func NewUserHandler(store *storage.AuthStore) *UserHandler {
return &UserHandler{store: store}
}
type createUserRequest struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
func HashPassword(password string) (string, error) {
salt := make([]byte, 16)
if _, err := rand.Read(salt); err != nil {
return "", err
}
hash := argon2.IDKey(
[]byte(password),
salt,
1,
64*1024,
4,
32,
)
return "argon2id$" +
base64.RawStdEncoding.EncodeToString(salt) + "$" +
base64.RawStdEncoding.EncodeToString(hash), nil
}
func VerifyPassword(password, encoded string) bool {
parts := strings.Split(encoded, "$")
if len(parts) != 3 || parts[0] != "argon2id" {
return false
}
salt, err := base64.RawStdEncoding.DecodeString(parts[1])
if err != nil || len(salt) != 16 {
return false
}
expected, err := base64.RawStdEncoding.DecodeString(parts[2])
if err != nil || len(expected) != 32 {
return false
}
actual := argon2.IDKey(
[]byte(password),
salt,
1,
64*1024,
4,
32,
)
return subtle.ConstantTimeCompare(actual, expected) == 1
}
func (h *UserHandler) Create(w http.ResponseWriter, r *http.Request) {
var req createUserRequest
if err := decodeOneObject(r, &req); err != nil {
writeError(w, r, http.StatusBadRequest,
"invalid_request", "invalid request body")
return
}
if !usernameRegexp.MatchString(req.Username) {
writeError(w, r, http.StatusBadRequest,
"invalid_request", "invalid username")
return
}
req.DisplayName = strings.TrimSpace(req.DisplayName)
nameLength := utf8.RuneCountInString(req.DisplayName)
if nameLength < 1 || nameLength > 100 {
writeError(w, r, http.StatusBadRequest,
"invalid_request", "invalid display_name")
return
}
passwordLength := utf8.RuneCountInString(req.Password)
if passwordLength < 12 || passwordLength > 128 {
writeError(w, r, http.StatusBadRequest,
"invalid_request",
"password must contain 12 to 128 characters")
return
}
passwordHash, err := HashPassword(req.Password)
if err != nil {
writeError(w, r, http.StatusInternalServerError,
"internal_error", "internal server error")
return
}
user := model.User{
ID: uuid.New(),
Username: req.Username,
DisplayName: req.DisplayName,
CreatedAt: time.Now().UTC().Truncate(time.Microsecond),
}
err = h.store.CreateUser(r.Context(), user, passwordHash)
if errors.Is(err, storage.ErrUsernameTaken) {
writeError(w, r, http.StatusConflict,
"conflict", "username already exists")
return
}
if err != nil {
writeError(w, r, http.StatusServiceUnavailable,
"unavailable", "service unavailable")
return
}
writeJSON(w, http.StatusCreated, user)
}
func (h *UserHandler) Me(w http.ResponseWriter, r *http.Request) {
user, ok := middleware.GetCurrentUser(r.Context())
if !ok {
writeError(w, r, http.StatusUnauthorized,
"unauthorized", "authentication required")
return
}
writeJSON(w, http.StatusOK, user)
}