// 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), 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" "net/http" "os" "path/filepath" "sort" "strings" "sync" "time" "unicode/utf8" "github.com/vblogio/upandown/internal/auth" ) 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. type Store struct { mu sync.Mutex file string tokens []*Token } // Open charge (ou crée) le fichier des jetons de dir. func Open(dir string) (*Store, error) { s := &Store{file: filepath.Join(dir, fileName)} b, err := os.ReadFile(s.file) switch { case errors.Is(err, os.ErrNotExist): case err != nil: return nil, err default: var d struct { Tokens []*Token `json:"tokens"` } if err := json.Unmarshal(b, &d); err != nil { return nil, errors.New(s.file + " invalide : " + err.Error()) } s.tokens = d.Tokens } return s, nil } func (s *Store) save() error { b, err := json.Marshal(map[string]any{"tokens": s.tokens}) 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 } s.mu.Lock() defer s.mu.Unlock() n := 0 for _, t := range s.tokens { if t.UserID == userID { n++ } } if n >= maxPerUser { return "", Info{}, ErrTooMany } secret := prefix + randomString(32) t := &Token{ID: randomString(9), Name: name, UserID: userID, Hash: hashOf(secret), Created: time.Now().UTC().Truncate(time.Second)} s.tokens = append(s.tokens, t) if err := s.save(); err != nil { s.tokens = s.tokens[:len(s.tokens)-1] 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 { s.mu.Lock() defer s.mu.Unlock() out := []Info{} for _, t := range s.tokens { 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 { s.mu.Lock() defer s.mu.Unlock() for i, t := range s.tokens { if t.ID == id && t.UserID == userID { s.tokens = append(s.tokens[:i:i], s.tokens[i+1:]...) return s.save() } } return ErrNotFound } // RevokeUser supprime tous les jetons d'un utilisateur (compte supprimé ou désactivé). func (s *Store) RevokeUser(userID string) { s.mu.Lock() defer s.mu.Unlock() kept := s.tokens[:0:0] for _, t := range s.tokens { if t.UserID != userID { kept = append(kept, t) } } if len(kept) != len(s.tokens) { s.tokens = kept _ = s.save() } } // 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) s.mu.Lock() defer s.mu.Unlock() for _, t := range s.tokens { if t.Hash == h { if time.Since(t.LastUsed) > touchEvery { t.LastUsed = time.Now().UTC().Truncate(time.Second) _ = s.save() } 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) } }