// Package tokens gère les jetons d'accès personnels à l'API : créés depuis // l'interface (sans expiration, révocables), ils permettent d'envoyer et de // télécharger des fichiers depuis un script (curl, rclone WebDAV non inclus...) // sans session de navigateur. // // Les jetons ne sont conservés que hachés (SHA-256) dans DATA_DIR/.tokens.json // (0600) ou dans le catalogue PostgreSQL, rattachés à l'utilisateur qui les a // créés : ils donnent accès à ses fichiers comme sa session, mais ne peuvent // pas gérer les jetons ni les comptes. package tokens import ( "context" "crypto/rand" "crypto/sha256" "encoding/base64" "encoding/hex" "encoding/json" "errors" "fmt" "log/slog" "net/http" "os" "path/filepath" "sort" "strings" "sync" "time" "unicode/utf8" "github.com/jackc/pgx/v5" "github.com/vblogio/upandown/internal/auth" "github.com/vblogio/upandown/internal/catalog" ) const ( fileName = ".tokens.json" prefix = "upd_" maxPerUser = 50 MaxNameLen = 80 touchEvery = time.Minute ) var ( ErrNotFound = errors.New("jeton introuvable") ErrInvalid = errors.New("nom de jeton invalide") ErrTooMany = errors.New("trop de jetons : en révoquer avant d'en créer") ) // Token est un jeton enregistré (sans le secret, que seul son hachage représente). type Token struct { ID string `json:"id"` Name string `json:"name"` UserID string `json:"userId"` Hash string `json:"hash"` Created time.Time `json:"created"` LastUsed time.Time `json:"lastUsed,omitzero"` } // Info est la vue d'un jeton renvoyée à l'interface. type Info struct { ID string `json:"id"` Name string `json:"name"` Created time.Time `json:"created"` LastUsed time.Time `json:"lastUsed,omitzero"` } func (t *Token) info() Info { return Info{ID: t.ID, Name: t.Name, Created: t.Created, LastUsed: t.LastUsed} } // Store conserve les jetons dans dir/.tokens.json, ou dans la table tokens du // catalogue PostgreSQL (UseCatalog), partagée par toutes les instances. type Store struct { mu sync.Mutex file string tokens map[string]*Token // mode fichier, par ID db *catalog.DB // mode catalogue } const ( table = "tokens" dbTimeout = 30 * time.Second ) // Open charge (ou crée) le fichier des jetons de dir. func Open(dir string) (*Store, error) { s := &Store{file: filepath.Join(dir, fileName), tokens: map[string]*Token{}} b, err := os.ReadFile(s.file) switch { case errors.Is(err, os.ErrNotExist): case err != nil: return nil, err default: list, err := decode(b) if err != nil { return nil, errors.New(s.file + " invalide : " + err.Error()) } s.tokens = list } return s, nil } func decode(b []byte) (map[string]*Token, error) { var d struct { Tokens []*Token `json:"tokens"` } if err := json.Unmarshal(b, &d); err != nil { return nil, err } m := make(map[string]*Token, len(d.Tokens)) for _, t := range d.Tokens { m[t.ID] = t } return m, nil } // UseCatalog range désormais les jetons dans le catalogue ; .tokens.json est // repris une seule fois puis renommé en .tokens.json.imported. À appeler au // démarrage, avant de servir des requêtes. func (s *Store) UseCatalog(db *catalog.DB) error { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute) defer cancel() err := db.ImportFileOnce(ctx, "global", "tokens", s.file, func(ctx context.Context, tx pgx.Tx, b []byte) error { m, err := decode(b) if err != nil { return err } return catalog.InsertDocs(ctx, tx, table, m) }) if err != nil { return fmt.Errorf("reprise des jetons : %w", err) } s.mu.Lock() s.db, s.tokens = db, nil s.mu.Unlock() return nil } // snapshot renvoie une copie de tous les jetons. func (s *Store) snapshot() (map[string]*Token, error) { if s.db != nil { ctx, cancel := context.WithTimeout(context.Background(), dbTimeout) defer cancel() return catalog.AllDocs[Token](ctx, s.db, table) } s.mu.Lock() defer s.mu.Unlock() return clone(s.tokens), nil } // update applique fn à tous les jetons, de façon atomique (rien n'est // enregistré si fn échoue). func (s *Store) update(fn func(map[string]*Token) error) error { if s.db != nil { ctx, cancel := context.WithTimeout(context.Background(), dbTimeout) defer cancel() return catalog.UpdateDocs(ctx, s.db, table, fn) } s.mu.Lock() defer s.mu.Unlock() next := clone(s.tokens) if err := fn(next); err != nil { return err } if err := s.save(next); err != nil { return err } s.tokens = next return nil } func clone(m map[string]*Token) map[string]*Token { out := make(map[string]*Token, len(m)) for id, t := range m { c := *t out[id] = &c } return out } // save écrit le fichier ; appelé sous mu. func (s *Store) save(m map[string]*Token) error { list := make([]*Token, 0, len(m)) for _, t := range m { list = append(list, t) } sort.Slice(list, func(i, j int) bool { if !list[i].Created.Equal(list[j].Created) { return list[i].Created.Before(list[j].Created) } return list[i].ID < list[j].ID }) b, err := json.Marshal(map[string]any{"tokens": list}) if err != nil { return err } tmp, err := os.CreateTemp(filepath.Dir(s.file), ".tmp-*") if err != nil { return err } defer os.Remove(tmp.Name()) if err := tmp.Chmod(0o600); err != nil { tmp.Close() return err } if _, err := tmp.Write(b); err != nil { tmp.Close() return err } if err := tmp.Close(); err != nil { return err } return os.Rename(tmp.Name(), s.file) } func hashOf(secret string) string { h := sha256.Sum256([]byte(secret)) return hex.EncodeToString(h[:]) } func randomString(n int) string { b := make([]byte, n) _, _ = rand.Read(b) return base64.RawURLEncoding.EncodeToString(b) } // Create crée un jeton pour userID ; le secret n'est renvoyé qu'ici. func (s *Store) Create(userID, name string) (string, Info, error) { name = strings.Join(strings.Fields(name), " ") if name == "" || !utf8.ValidString(name) || utf8.RuneCountInString(name) > MaxNameLen { return "", Info{}, ErrInvalid } secret := prefix + randomString(32) t := &Token{ID: randomString(9), Name: name, UserID: userID, Hash: hashOf(secret), Created: time.Now().UTC().Truncate(time.Second)} err := s.update(func(m map[string]*Token) error { n := 0 for _, o := range m { if o.UserID == userID { n++ } } if n >= maxPerUser { return ErrTooMany } c := *t m[t.ID] = &c return nil }) if err != nil { return "", Info{}, err } return secret, t.info(), nil } // List renvoie les jetons de userID, les plus récents en premier. func (s *Store) List(userID string) []Info { m, err := s.snapshot() if err != nil { slog.Error("jetons : lecture", "err", err) } out := []Info{} for _, t := range m { if t.UserID == userID { out = append(out, t.info()) } } sort.Slice(out, func(i, j int) bool { return out[i].Created.After(out[j].Created) }) return out } // Revoke supprime un jeton de userID. func (s *Store) Revoke(userID, id string) error { return s.update(func(m map[string]*Token) error { if t, ok := m[id]; !ok || t.UserID != userID { return ErrNotFound } delete(m, id) return nil }) } // RevokeUser supprime tous les jetons d'un utilisateur (compte supprimé ou désactivé). func (s *Store) RevokeUser(userID string) { err := s.update(func(m map[string]*Token) error { for id, t := range m { if t.UserID == userID { delete(m, id) } } return nil }) if err != nil { slog.Error("jetons : révocation", "user", userID, "err", err) } } // Lookup renvoie le jeton correspondant à secret. func (s *Store) Lookup(secret string) (Token, bool) { if !strings.HasPrefix(secret, prefix) { return Token{}, false } h := hashOf(secret) if s.db != nil { ctx, cancel := context.WithTimeout(context.Background(), dbTimeout) defer cancel() t, err := catalog.FindDoc[Token](ctx, s.db, table, "hash", h) if err != nil { slog.Error("jetons : lecture", "err", err) } if t == nil { return Token{}, false } if time.Since(t.LastUsed) > touchEvery { t.LastUsed = time.Now().UTC().Truncate(time.Second) if err := catalog.ReplaceDoc(ctx, s.db, table, t.ID, t); err != nil { slog.Warn("jetons : date d'utilisation non enregistrée", "err", err) } } return *t, true } s.mu.Lock() defer s.mu.Unlock() for _, t := range s.tokens { if t.Hash == h { if time.Since(t.LastUsed) > touchEvery { next := clone(s.tokens) next[t.ID].LastUsed = time.Now().UTC().Truncate(time.Second) if s.save(next) == nil { s.tokens = next t = next[t.ID] } } return *t, true } } return Token{}, false } // --- HTTP --------------------------------------------------------------------------------- type tokenKey struct{} // FromContext renvoie le jeton qui a authentifié la requête (nil : session). func FromContext(ctx context.Context) *Token { t, _ := ctx.Value(tokenKey{}).(*Token) return t } // Server expose les jetons en HTTP. type Server struct { Store *Store // Resolve renvoie l'utilisateur actif d'un identifiant de compte (nil, true : // pas d'authentification intégrée ; _, false : compte inexistant ou inactif). Resolve func(userID string) (*auth.User, bool) // UserID identifie l'utilisateur d'une requête de l'interface. UserID func(*http.Request) string } func writeJSON(w http.ResponseWriter, status int, v any) { w.Header().Set("Content-Type", "application/json") w.WriteHeader(status) _ = json.NewEncoder(w).Encode(v) } func bearer(r *http.Request) (string, bool) { scheme, tok, ok := strings.Cut(r.Header.Get("Authorization"), " ") if !ok || !strings.EqualFold(scheme, "Bearer") { return "", false } return strings.TrimSpace(tok), true } // Middleware authentifie les requêtes porteuses d'un jeton (Authorization: // Bearer) et les transmet directement à mux avec l'utilisateur du jeton ; les // autres suivent next (session). func (s *Server) Middleware(next, mux http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { secret, ok := bearer(r) if !ok { next.ServeHTTP(w, r) return } t, valid := s.Store.Lookup(secret) var u *auth.User if valid { u, valid = s.Resolve(t.UserID) } if !valid { w.Header().Set("WWW-Authenticate", `Bearer error="invalid_token"`) writeJSON(w, http.StatusUnauthorized, map[string]string{"error": "jeton d'accès invalide ou révoqué"}) return } ctx := context.WithValue(r.Context(), tokenKey{}, &t) if u != nil { ctx = auth.WithUser(ctx, u) } mux.ServeHTTP(w, r.WithContext(ctx)) }) } // Register enregistre les routes des jetons. // // GET /api/tokens jetons de l'utilisateur // POST /api/tokens {"name"} nouveau jeton (renvoyé une seule fois) // DELETE /api/tokens/{id} révocation func (s *Server) Register(mux *http.ServeMux) { mux.HandleFunc("GET /api/tokens", s.session(func(w http.ResponseWriter, r *http.Request) { writeJSON(w, http.StatusOK, s.Store.List(s.UserID(r))) })) mux.HandleFunc("POST /api/tokens", s.session(func(w http.ResponseWriter, r *http.Request) { var req struct { Name string `json:"name"` } if json.NewDecoder(http.MaxBytesReader(w, r.Body, 4096)).Decode(&req) != nil { writeJSON(w, http.StatusBadRequest, map[string]string{"error": "requête JSON invalide"}) return } secret, info, err := s.Store.Create(s.UserID(r), req.Name) if err != nil { status := http.StatusInternalServerError if errors.Is(err, ErrInvalid) || errors.Is(err, ErrTooMany) { status = http.StatusBadRequest } writeJSON(w, status, map[string]string{"error": err.Error()}) return } w.Header().Set("Cache-Control", "no-store") writeJSON(w, http.StatusCreated, struct { Info Token string `json:"token"` }{info, secret}) })) mux.HandleFunc("DELETE /api/tokens/{id}", s.session(func(w http.ResponseWriter, r *http.Request) { if err := s.Store.Revoke(s.UserID(r), r.PathValue("id")); err != nil { status := http.StatusInternalServerError if errors.Is(err, ErrNotFound) { status = http.StatusNotFound } writeJSON(w, status, map[string]string{"error": err.Error()}) return } w.WriteHeader(http.StatusNoContent) })) } // session refuse les requêtes authentifiées par un jeton : un jeton ne peut // pas créer, lister ni révoquer de jetons. func (s *Server) session(h http.HandlerFunc) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if FromContext(r.Context()) != nil { writeJSON(w, http.StatusForbidden, map[string]string{"error": "gestion des jetons réservée à la session de l'interface"}) return } h(w, r) } }