- tokens.Store : UseCatalog, reprise unique de .tokens.json, recherche par empreinte indexée, date d'utilisation mise à jour sans verrou global. - Réglages d'administration et logo en base (app_settings, app_blobs), reprise unique de .settings.json et .logo.png. - Avec DATABASE_URL, SHARE_SECRET et SESSION_SECRET sont obligatoires (SESSION_SECRET non exigé avec AUTH_MODE=none) ; la forme hex:<clé> reprend un ancien .share-secret / .session-secret sans casser les liens ni les sessions. Variables *_FILE acceptées. - docker-compose : les deux secrets sont exigés au lancement. - Tests : comptes, jetons et réglages partagés entre deux instances. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
458 lines
12 KiB
Go
458 lines
12 KiB
Go
// 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)
|
|
}
|
|
}
|