UploadFile / auth.go
ddosvn's picture
Deploy Upload ThTuanIT Full-stack (Go + Next.js + Python hf_xet + MongoDB)
7c5da52 verified
Raw History Blame Contribute Delete
15 kB
package main
import (
"crypto/hmac"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"net/http"
"os"
"strings"
"sync"
"time"
)
type PermissionSet struct {
CanUpload bool `json:"can_upload" bson:"can_upload"`
CanDelete bool `json:"can_delete" bson:"can_delete"`
CanRename bool `json:"can_rename" bson:"can_rename"`
}
type UserAccount struct {
Username string `json:"username" bson:"username"`
DisplayName string `json:"display_name" bson:"display_name"`
Role string `json:"role" bson:"role"` // "admin" | "user"
PasswordSalt string `json:"password_salt,omitempty" bson:"password_salt"`
PasswordHash string `json:"password_hash,omitempty" bson:"password_hash"`
Permissions PermissionSet `json:"permissions" bson:"permissions"`
Active bool `json:"active" bson:"active"`
CreatedAt string `json:"created_at" bson:"created_at"`
}
type PublicUser struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Role string `json:"role"`
Permissions PermissionSet `json:"permissions"`
Active bool `json:"active"`
CreatedAt string `json:"created_at"`
}
func (u UserAccount) Public() PublicUser {
return PublicUser{
Username: u.Username,
DisplayName: u.DisplayName,
Role: u.Role,
Permissions: u.Permissions,
Active: u.Active,
CreatedAt: u.CreatedAt,
}
}
type UserStore struct {
mu sync.RWMutex
path string
secret []byte
users map[string]UserAccount
mongo *MongoStore
}
func (s *UserStore) AttachMongo(m *MongoStore) {
if m == nil {
return
}
s.mu.Lock()
defer s.mu.Unlock()
s.mongo = m
dbUsers, err := m.LoadAllUsers()
if err == nil {
inMongo := make(map[string]bool)
for _, u := range dbUsers {
key := strings.ToLower(strings.TrimSpace(u.Username))
if key != "" {
s.users[key] = u
inMongo[key] = true
}
}
// Migrate any local users not yet in MongoDB
for key, u := range s.users {
if !inMongo[key] {
_ = m.UpsertUserDoc(u)
}
}
_ = s.saveLocked()
}
}
func NewUserStore(filePath, secretKey string) (*UserStore, error) {
s := &UserStore{
path: filePath,
secret: []byte(secretKey),
users: make(map[string]UserAccount),
}
if err := s.load(); err != nil {
return nil, err
}
return s, nil
}
func hashPassword(password, salt string) string {
h := sha256.New()
h.Write([]byte(salt + ":" + password))
return hex.EncodeToString(h.Sum(nil))
}
func randomHex(n int) string {
b := make([]byte, n)
_, _ = rand.Read(b)
return hex.EncodeToString(b)
}
func (s *UserStore) load() error {
s.mu.Lock()
defer s.mu.Unlock()
data, err := os.ReadFile(s.path)
if err != nil {
if !errors.Is(err, os.ErrNotExist) {
return err
}
// Seed default admin ("admin" / "admin") and demo user ("user" / "user123")
now := time.Now().Format("2006-01-02 15:04:05")
adminSalt := randomHex(16)
userSalt := randomHex(16)
s.users["admin"] = UserAccount{
Username: "admin",
DisplayName: "Administrator",
Role: "admin",
PasswordSalt: adminSalt,
PasswordHash: hashPassword("admin", adminSalt),
Permissions: PermissionSet{
CanUpload: true,
CanDelete: true,
CanRename: true,
},
Active: true,
CreatedAt: now,
}
s.users["user"] = UserAccount{
Username: "user",
DisplayName: "Khách hàng / User",
Role: "user",
PasswordSalt: userSalt,
PasswordHash: hashPassword("user123", userSalt),
Permissions: PermissionSet{
CanUpload: true,
CanDelete: false,
CanRename: false,
},
Active: true,
CreatedAt: now,
}
return s.saveLocked()
}
var list []UserAccount
if err := json.Unmarshal(data, &list); err != nil {
return err
}
for _, u := range list {
s.users[strings.ToLower(u.Username)] = u
}
return nil
}
func (s *UserStore) saveLocked() error {
list := make([]UserAccount, 0, len(s.users))
for _, u := range s.users {
list = append(list, u)
}
data, err := json.MarshalIndent(list, "", " ")
if err != nil {
return err
}
return os.WriteFile(s.path, data, 0600)
}
func (s *UserStore) Authenticate(username, password string) (UserAccount, bool) {
s.mu.RLock()
defer s.mu.RUnlock()
u, ok := s.users[strings.ToLower(strings.TrimSpace(username))]
if !ok || !u.Active {
return UserAccount{}, false
}
expected := hashPassword(password, u.PasswordSalt)
if subtle.ConstantTimeCompare([]byte(expected), []byte(u.PasswordHash)) != 1 {
return UserAccount{}, false
}
return u, true
}
func (s *UserStore) Get(username string) (UserAccount, bool) {
s.mu.RLock()
defer s.mu.RUnlock()
u, ok := s.users[strings.ToLower(strings.TrimSpace(username))]
return u, ok
}
func (s *UserStore) List() []PublicUser {
s.mu.RLock()
defer s.mu.RUnlock()
out := make([]PublicUser, 0, len(s.users))
for _, u := range s.users {
out = append(out, u.Public())
}
return out
}
func (s *UserStore) UpsertUser(username, displayName, role, password string, perms PermissionSet, active bool) (PublicUser, error) {
s.mu.Lock()
defer s.mu.Unlock()
key := strings.ToLower(strings.TrimSpace(username))
if key == "" {
return PublicUser{}, errors.New("username is required")
}
if role != "admin" && role != "user" {
role = "user"
}
if role == "admin" {
perms = PermissionSet{CanUpload: true, CanDelete: true, CanRename: true}
}
existing, exists := s.users[key]
if !exists {
if strings.TrimSpace(password) == "" {
return PublicUser{}, errors.New("password is required for new user")
}
salt := randomHex(16)
existing = UserAccount{
Username: strings.TrimSpace(username),
DisplayName: strings.TrimSpace(displayName),
Role: role,
PasswordSalt: salt,
PasswordHash: hashPassword(password, salt),
Permissions: perms,
Active: active,
CreatedAt: time.Now().Format("2006-01-02 15:04:05"),
}
if existing.DisplayName == "" {
existing.DisplayName = existing.Username
}
} else {
if displayName != "" {
existing.DisplayName = strings.TrimSpace(displayName)
}
existing.Role = role
existing.Permissions = perms
existing.Active = active
if strings.TrimSpace(password) != "" {
salt := randomHex(16)
existing.PasswordSalt = salt
existing.PasswordHash = hashPassword(password, salt)
}
}
s.users[key] = existing
if s.mongo != nil {
if err := s.mongo.UpsertUserDoc(existing); err != nil {
return PublicUser{}, err
}
}
if err := s.saveLocked(); err != nil {
return PublicUser{}, err
}
return existing.Public(), nil
}
func (s *UserStore) DeleteUser(username string) error {
s.mu.Lock()
defer s.mu.Unlock()
key := strings.ToLower(strings.TrimSpace(username))
if key == "admin" {
return errors.New("không thể xóa tài khoản admin gốc")
}
if _, ok := s.users[key]; !ok {
return errors.New("không tìm thấy tài khoản")
}
delete(s.users, key)
if s.mongo != nil {
if err := s.mongo.DeleteUserDoc(key); err != nil {
return err
}
}
return s.saveLocked()
}
// --- Stateless HMAC Token ---
type tokenPayload struct {
Username string `json:"u"`
Exp int64 `json:"e"`
}
func (s *UserStore) IssueToken(username string, ttl time.Duration) (string, error) {
payload := tokenPayload{
Username: strings.ToLower(strings.TrimSpace(username)),
Exp: time.Now().Add(ttl).Unix(),
}
b, err := json.Marshal(payload)
if err != nil {
return "", err
}
p64 := base64.RawURLEncoding.EncodeToString(b)
mac := hmac.New(sha256.New, s.secret)
mac.Write([]byte(p64))
sig := base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
return p64 + "." + sig, nil
}
func (s *UserStore) VerifyToken(token string) (UserAccount, bool) {
parts := strings.Split(token, ".")
if len(parts) != 2 {
return UserAccount{}, false
}
mac := hmac.New(sha256.New, s.secret)
mac.Write([]byte(parts[0]))
expectedSig := base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
if subtle.ConstantTimeCompare([]byte(parts[1]), []byte(expectedSig)) != 1 {
return UserAccount{}, false
}
raw, err := base64.RawURLEncoding.DecodeString(parts[0])
if err != nil {
return UserAccount{}, false
}
var p tokenPayload
if err := json.Unmarshal(raw, &p); err != nil {
return UserAccount{}, false
}
if time.Now().Unix() > p.Exp {
return UserAccount{}, false
}
u, ok := s.Get(p.Username)
if !ok || !u.Active {
return UserAccount{}, false
}
return u, true
}
// --- HTTP Handlers for Auth & User Management ---
func (a *App) resolveRequestUser(r *http.Request) (UserAccount, bool) {
// 1. Check API Key (legacy / CLI / admin root key)
providedKey := r.Header.Get("X-API-Key")
if providedKey == "" {
providedKey = r.URL.Query().Get("api_key")
}
if len(providedKey) == len(a.cfg.APIKey) && subtle.ConstantTimeCompare([]byte(providedKey), []byte(a.cfg.APIKey)) == 1 {
if u, ok := a.users.Get("admin"); ok {
return u, true
}
return UserAccount{
Username: "admin",
DisplayName: "API Key Admin",
Role: "admin",
Permissions: PermissionSet{CanUpload: true, CanDelete: true, CanRename: true},
Active: true,
}, true
}
// 2. Check Bearer token or query token or cookie
token := ""
if authHeader := r.Header.Get("Authorization"); strings.HasPrefix(authHeader, "Bearer ") {
token = strings.TrimPrefix(authHeader, "Bearer ")
}
if token == "" {
token = r.URL.Query().Get("token")
}
if token == "" {
if c, err := r.Cookie("hf_session"); err == nil {
token = c.Value
}
}
if token == "" {
return UserAccount{}, false
}
// Allow Bearer <API_KEY> as well
if len(token) == len(a.cfg.APIKey) && subtle.ConstantTimeCompare([]byte(token), []byte(a.cfg.APIKey)) == 1 {
if u, ok := a.users.Get("admin"); ok {
return u, true
}
}
return a.users.VerifyToken(token)
}
func (a *App) handleLogin(w http.ResponseWriter, r *http.Request) {
var body struct {
Username string `json:"username"`
Password string `json:"password"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
writeJSON(w, http.StatusBadRequest, APIError{Error: "invalid_json", Detail: err.Error()})
return
}
u, ok := a.users.Authenticate(body.Username, body.Password)
if !ok {
writeJSON(w, http.StatusUnauthorized, APIError{Error: "invalid_credentials", Detail: "Sai tài khoản, mật khẩu hoặc tài khoản đã bị khóa"})
return
}
token, err := a.users.IssueToken(u.Username, 7*24*time.Hour)
if err != nil {
writeJSON(w, http.StatusInternalServerError, APIError{Error: "token_error", Detail: err.Error()})
return
}
http.SetCookie(w, &http.Cookie{
Name: "hf_session",
Value: token,
Path: "/",
HttpOnly: true,
SameSite: http.SameSiteLaxMode,
MaxAge: 7 * 24 * 3600,
})
writeJSON(w, http.StatusOK, map[string]any{
"ok": true,
"token": token,
"user": u.Public(),
})
}
func (a *App) handleRegister(w http.ResponseWriter, r *http.Request) {
var body struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
writeJSON(w, http.StatusBadRequest, APIError{Error: "invalid_json", Detail: err.Error()})
return
}
username := strings.TrimSpace(body.Username)
if len(username) < 3 || len(body.Password) < 4 {
writeJSON(w, http.StatusBadRequest, APIError{Error: "weak_input", Detail: "Tên đăng nhập tối thiểu 3 ký tự, mật khẩu tối thiểu 4 ký tự"})
return
}
if _, exists := a.users.Get(username); exists {
writeJSON(w, http.StatusConflict, APIError{Error: "user_exists", Detail: "Tên tài khoản này đã tồn tại"})
return
}
pub, err := a.users.UpsertUser(username, body.DisplayName, "user", body.Password, PermissionSet{
CanUpload: true,
CanDelete: false,
CanRename: false,
}, true)
if err != nil {
writeJSON(w, http.StatusBadRequest, APIError{Error: "register_failed", Detail: err.Error()})
return
}
token, _ := a.users.IssueToken(pub.Username, 7*24*time.Hour)
http.SetCookie(w, &http.Cookie{
Name: "hf_session",
Value: token,
Path: "/",
HttpOnly: true,
SameSite: http.SameSiteLaxMode,
MaxAge: 7 * 24 * 3600,
})
writeJSON(w, http.StatusCreated, map[string]any{
"ok": true,
"token": token,
"user": pub,
})
}
func (a *App) handleLogout(w http.ResponseWriter, r *http.Request) {
http.SetCookie(w, &http.Cookie{
Name: "hf_session",
Value: "",
Path: "/",
HttpOnly: true,
MaxAge: -1,
})
writeJSON(w, http.StatusOK, map[string]any{"ok": true})
}
func (a *App) handleMe(w http.ResponseWriter, r *http.Request) {
u, ok := a.resolveRequestUser(r)
if !ok {
writeJSON(w, http.StatusUnauthorized, APIError{Error: "unauthorized", Detail: "Vui lòng đăng nhập"})
return
}
writeJSON(w, http.StatusOK, map[string]any{
"ok": true,
"user": u.Public(),
})
}
func (a *App) handleAdminListUsers(w http.ResponseWriter, r *http.Request) {
u, ok := a.resolveRequestUser(r)
if !ok || u.Role != "admin" {
writeJSON(w, http.StatusForbidden, APIError{Error: "forbidden", Detail: "Chỉ Admin mới có quyền quản lý người dùng"})
return
}
writeJSON(w, http.StatusOK, map[string]any{
"ok": true,
"users": a.users.List(),
})
}
func (a *App) handleAdminSaveUser(w http.ResponseWriter, r *http.Request) {
u, ok := a.resolveRequestUser(r)
if !ok || u.Role != "admin" {
writeJSON(w, http.StatusForbidden, APIError{Error: "forbidden", Detail: "Chỉ Admin mới có quyền chỉnh sửa người dùng"})
return
}
var body struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Role string `json:"role"`
Password string `json:"password"`
Permissions PermissionSet `json:"permissions"`
Active bool `json:"active"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
writeJSON(w, http.StatusBadRequest, APIError{Error: "invalid_json", Detail: err.Error()})
return
}
saved, err := a.users.UpsertUser(body.Username, body.DisplayName, body.Role, body.Password, body.Permissions, body.Active)
if err != nil {
writeJSON(w, http.StatusBadRequest, APIError{Error: "save_user_failed", Detail: err.Error()})
return
}
writeJSON(w, http.StatusOK, map[string]any{
"ok": true,
"user": saved,
})
}
func (a *App) handleAdminDeleteUser(w http.ResponseWriter, r *http.Request) {
u, ok := a.resolveRequestUser(r)
if !ok || u.Role != "admin" {
writeJSON(w, http.StatusForbidden, APIError{Error: "forbidden", Detail: "Chỉ Admin mới có quyền xóa người dùng"})
return
}
username := r.URL.Query().Get("username")
if err := a.users.DeleteUser(username); err != nil {
writeJSON(w, http.StatusBadRequest, APIError{Error: "delete_user_failed", Detail: err.Error()})
return
}
writeJSON(w, http.StatusOK, map[string]any{"ok": true, "username": username})
}