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 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}) }