Spaces:
Running
Running
Download auth.go from TwanAPI/UploadFile: direct link, hf CLI and curl.
- Browser
- Download file 15 kB
-
https://huggingface.co/spaces/TwanAPI/UploadFile/resolve/main/auth.go
- Command line
-
hf download hf://spaces/TwanAPI/UploadFile/auth.go
-
curl -L -o auth.go https://huggingface.co/spaces/TwanAPI/UploadFile/resolve/main/auth.go
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}) | |
| } | |