From 479aa2477c0d959494fb0c4abeb519815b90907b Mon Sep 17 00:00:00 2001 From: claude Date: Fri, 20 Nov 2026 17:38:07 +0100 Subject: [PATCH] =?UTF-8?q?Lot=202=20(fin)=20:=20jetons,=20r=C3=A9glages?= =?UTF-8?q?=20et=20secrets=20communs=20en=20mode=20cluster?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 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: 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 Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB --- .env.example | 2 + README.md | 4 +- cmd/server/main.go | 39 ++++-- docker-compose.yml | 4 +- internal/auth/session.go | 12 +- internal/storage/catalog.go | 30 +++++ internal/storage/settings.go | 71 ++++++++++- internal/storage/share.go | 30 ++++- internal/tokens/tokens.go | 219 +++++++++++++++++++++++++-------- internal/tokens/tokens_test.go | 96 +++++++++++++++ 10 files changed, 438 insertions(+), 69 deletions(-) create mode 100644 internal/tokens/tokens_test.go diff --git a/.env.example b/.env.example index 09f0471..1ad9b24 100644 --- a/.env.example +++ b/.env.example @@ -16,6 +16,8 @@ OIDC_NAME=SSO OIDC_ALLOWED_GROUPS= OIDC_ADMIN_GROUPS= OIDC_ADMIN_EMAILS= +# Clés communes à toutes les instances (obligatoires avec PostgreSQL), +# 16 caractères minimum : openssl rand -hex 32 SESSION_SECRET= PUBLIC_URL= MAX_UPLOAD_MB=0 diff --git a/README.md b/README.md index 1770b1e..508bfad 100644 --- a/README.md +++ b/README.md @@ -44,8 +44,8 @@ Pour imposer l'administrateur : `ADMIN_USER` et `ADMIN_PASSWORD` dans `.env`. Le | `COMMON_READONLY` | `false` | Commun en lecture seule pour les non-administrateurs | | `TRASH_DAYS` | `0` | Purge de la poubelle (0 : jamais) | | `HISTORY_KEEP` / `HISTORY_INTERVAL` / `HISTORY_MAX_AGE` | `10` / `0` / `0` | Versions gardées par fichier, écart minimal, âge maximal | -| `SESSION_TTL` / `SESSION_SECRET` | `24h` / aléatoire | Session ; clé de signature (sinon `DATA_DIR/.session-secret`) | -| `SHARE_SECRET` | aléatoire | Clé de signature des liens de partage | +| `SESSION_TTL` / `SESSION_SECRET` | `24h` / aléatoire | Session ; clé de signature (sinon `DATA_DIR/.session-secret`). Obligatoire avec `DATABASE_URL` ; `hex:` garde les sessions ouvertes | +| `SHARE_SECRET` | aléatoire | Clé de signature des liens de partage. Obligatoire avec `DATABASE_URL` ; `hex:` garde valides les liens existants | | `PUBLIC_URL` | | URL publique (cookies `Secure`) | Les valeurs d'inscription, de quota, de lecture seule et de poubelle sont des défauts : une fois modifiées dans l'interface, c'est le réglage de l'interface qui prime. diff --git a/cmd/server/main.go b/cmd/server/main.go index 0b93656..62597cc 100644 --- a/cmd/server/main.go +++ b/cmd/server/main.go @@ -121,11 +121,25 @@ func main() { fatal("REGISTRATION invalide (closed, approval ou open)") } // Clé de signature des liens de partage : SHARE_SECRET, sinon DATA_DIR/.share-secret. - if secret := os.Getenv("SHARE_SECRET"); secret != "" { - if len(secret) < 16 { - fatal("SHARE_SECRET trop court (16 caractères minimum)") + // Avec le catalogue PostgreSQL, toutes les instances doivent partager la + // même clé (et celle des sessions) : SHARE_SECRET et SESSION_SECRET sont + // alors obligatoires. + dsn := secretEnv("DATABASE_URL") + if dsn != "" { + required := []string{"SHARE_SECRET", "SESSION_SECRET"} + if strings.EqualFold(os.Getenv("AUTH_MODE"), "none") { + required = required[:1] // pas de sessions + } + for _, name := range required { + if secretEnv(name) == "" { + fatal(name + " obligatoire avec DATABASE_URL (clé commune à toutes les instances)") + } + } + } + if secret := secretEnv("SHARE_SECRET"); secret != "" { + if err := store.SetShareSecret(secret); err != nil { + fatal("SHARE_SECRET", "err", err) } - store.SetShareSecret(secret) } ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) @@ -134,8 +148,9 @@ func main() { spaces := storage.NewSpaces(store) // Catalogue PostgreSQL partagé (mode cluster) : DATABASE_URL ou DATABASE_URL_FILE. // Sans lui, les métadonnées restent dans les fichiers JSON de DATA_DIR. - if dsn := secretEnv("DATABASE_URL"); dsn != "" { - db, err := catalog.Open(ctx, dsn, envDuration("DATABASE_WAIT", 60*time.Second)) + var db *catalog.DB + if dsn != "" { + db, err = catalog.Open(ctx, dsn, envDuration("DATABASE_WAIT", 60*time.Second)) if err != nil { fatal("catalogue PostgreSQL", "err", err) } @@ -156,6 +171,11 @@ func main() { if err != nil { fatal("jetons d'accès", "err", err) } + if db != nil { + if err := tokenStore.UseCatalog(db); err != nil { + fatal("jetons d'accès", "err", err) + } + } ts := &tokens.Server{Store: tokenStore, UserID: api.UserID} switch mode { @@ -168,6 +188,11 @@ func main() { if err != nil { fatal("comptes", "err", err) } + if db != nil { + if err := accounts.UseCatalog(db); err != nil { + fatal("comptes", "err", err) + } + } handler.Accounts = accounts a, err := authentication(ctx, mode, dataDir, accounts, store, handler) if err != nil { @@ -219,7 +244,7 @@ func main() { // authentication prépare l'authentification locale (comptes, inscription) et/ou OIDC. func authentication(ctx context.Context, mode, dataDir string, accounts *auth.Accounts, store *storage.Store, h *api.Handler) (*auth.Auth, error) { - secret, err := auth.LoadSecret(os.Getenv("SESSION_SECRET"), dataDir) + secret, err := auth.LoadSecret(secretEnv("SESSION_SECRET"), dataDir) if err != nil { return nil, err } diff --git a/docker-compose.yml b/docker-compose.yml index 90ef871..0f46d56 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -29,7 +29,7 @@ services: OIDC_ADMIN_EMAILS: ${OIDC_ADMIN_EMAILS:-} OIDC_LOGOUT: ${OIDC_LOGOUT:-true} SESSION_TTL: ${SESSION_TTL:-24h} - SESSION_SECRET: ${SESSION_SECRET:-} + SESSION_SECRET: ${SESSION_SECRET:?SESSION_SECRET requis (openssl rand -hex 32)} PUBLIC_URL: ${PUBLIC_URL:-} # Dépôts : taille maximale d'un fichier (Mo, 0 : illimité) ; quota par utilisateur (Mo, 0 : illimité). MAX_UPLOAD_MB: ${MAX_UPLOAD_MB:-0} @@ -40,7 +40,7 @@ services: HISTORY_KEEP: ${HISTORY_KEEP:-10} HISTORY_INTERVAL: ${HISTORY_INTERVAL:-0} HISTORY_MAX_AGE: ${HISTORY_MAX_AGE:-0} - SHARE_SECRET: ${SHARE_SECRET:-} + SHARE_SECRET: ${SHARE_SECRET:?SHARE_SECRET requis (openssl rand -hex 32)} # Catalogue PostgreSQL partagé (indispensable pour plusieurs instances). # Plusieurs hôtes possibles pour une base répliquée : # postgres://upandown:@pg1,pg2/upandown?target_session_attrs=read-write diff --git a/internal/auth/session.go b/internal/auth/session.go index 41c4105..e727936 100644 --- a/internal/auth/session.go +++ b/internal/auth/session.go @@ -101,9 +101,17 @@ func randomString(n int) string { } // LoadSecret renvoie la clé de signature des sessions : secret si fourni -// (16 caractères minimum), sinon le contenu de dir/.session-secret, créé -// aléatoirement au premier démarrage (0600). +// (16 caractères minimum, ou « hex: » repris d'un .session-secret), +// sinon le contenu de dir/.session-secret, créé aléatoirement au premier +// démarrage (0600). func LoadSecret(secret, dir string) ([]byte, error) { + if h, ok := strings.CutPrefix(secret, "hex:"); ok { // contenu d'un ancien .session-secret + k, err := hex.DecodeString(strings.TrimSpace(h)) + if err != nil || len(k) < 32 { + return nil, errors.New("SESSION_SECRET hex: invalide (64 caractères hexadécimaux attendus)") + } + return k, nil + } if secret != "" { if len(secret) < 16 { return nil, errors.New("SESSION_SECRET trop court (16 caractères minimum)") diff --git a/internal/storage/catalog.go b/internal/storage/catalog.go index f30e7b0..d46aeda 100644 --- a/internal/storage/catalog.go +++ b/internal/storage/catalog.go @@ -39,12 +39,42 @@ func (s *Store) UseCatalog(db *catalog.DB, root string) error { if err := c.importJSON(s.root); err != nil { return fmt.Errorf("reprise des métadonnées de %s : %w", root, err) } + if err := c.importSettings(s.root); err != nil { + return fmt.Errorf("reprise des réglages de %s : %w", root, err) + } s.metaMu.Lock() s.cat, s.meta = c, nil s.metaMu.Unlock() return nil } +// settingsTable : réglages d'administration (un document par racine). +const settingsTable = "app_settings" + +func (c *catalogRef) settingsID() string { return "settings:" + c.root } +func (c *catalogRef) logoKey() string { return "logo:" + c.root } + +// importSettings reprend une seule fois .settings.json et .logo.png. +func (c *catalogRef) importSettings(dir string) error { + ctx, cancel := context.WithTimeout(context.Background(), time.Minute) + defer cancel() + err := c.db.ImportFileOnce(ctx, c.root, "settings", filepath.Join(dir, settingsFile), + func(ctx context.Context, tx pgx.Tx, b []byte) error { + var d settingsDisk + if err := json.Unmarshal(b, &d); err != nil { + return err + } + return catalog.InsertDocs(ctx, tx, settingsTable, map[string]*settingsDisk{c.settingsID(): &d}) + }) + if err != nil { + return err + } + return c.db.ImportFileOnce(ctx, c.root, "logo", filepath.Join(dir, logoFile), + func(ctx context.Context, tx pgx.Tx, b []byte) error { + return catalog.PutBlobTx(ctx, tx, c.logoKey(), b) + }) +} + func ctxOp() (context.Context, context.CancelFunc) { return context.WithTimeout(context.Background(), opTimeout) } diff --git a/internal/storage/settings.go b/internal/storage/settings.go index 6747e29..a76d403 100644 --- a/internal/storage/settings.go +++ b/internal/storage/settings.go @@ -14,11 +14,14 @@ import ( "strconv" "strings" "unicode/utf8" + + "github.com/vblogio/upandown/internal/catalog" ) // Paramètres partagés par tous les navigateurs : .settings.json et .logo.png à -// la racine. Les valeurs que l'administrateur n'a pas modifiées viennent des -// variables d'environnement (SettingsDefaults). +// la racine, ou en base quand le catalogue PostgreSQL est branché. Les +// valeurs que l'administrateur n'a pas modifiées viennent des variables +// d'environnement (SettingsDefaults). const ( settingsFile = ".settings.json" @@ -131,6 +134,15 @@ type settingsDisk struct { func (s *Store) readSettingsDisk() (settingsDisk, error) { var d settingsDisk + if s.cat != nil { + ctx, cancel := ctxOp() + defer cancel() + p, err := catalog.GetDoc[settingsDisk](ctx, s.cat.db, settingsTable, s.cat.settingsID()) + if p != nil { + d = *p + } + return d, err + } b, err := os.ReadFile(filepath.Join(s.root, settingsFile)) switch { case errors.Is(err, fs.ErrNotExist): @@ -149,6 +161,24 @@ func (s *Store) readSettingsDisk() (settingsDisk, error) { func (s *Store) updateSettings(edit func(*settingsDisk)) (Settings, error) { s.settingsMu.Lock() defer s.settingsMu.Unlock() + if s.cat != nil { + ctx, cancel := ctxOp() + defer cancel() + id := s.cat.settingsID() + err := catalog.UpdateDocs(ctx, s.cat.db, settingsTable, func(m map[string]*settingsDisk) error { + d := m[id] + if d == nil { + d = &settingsDisk{} + m[id] = d + } + edit(d) + return nil + }) + if err != nil { + return Settings{}, err + } + return s.readSettings() + } d, err := s.readSettingsDisk() if err != nil { return Settings{}, err @@ -212,7 +242,17 @@ func (s *Store) readSettings() (Settings, error) { st.Preview.Shares = *p.Shares } } - if fi, err := os.Stat(filepath.Join(s.root, logoFile)); err == nil { + if s.cat != nil { + ctx, cancel := ctxOp() + defer cancel() + v, err := s.cat.db.BlobVersion(ctx, s.cat.logoKey()) + if err != nil { + return Settings{}, err + } + if v != 0 { + st.Logo = strconv.FormatInt(v, 36) + } + } else if fi, err := os.Stat(filepath.Join(s.root, logoFile)); err == nil { st.Logo = strconv.FormatInt(fi.ModTime().UnixNano(), 36) } return st, nil @@ -325,6 +365,15 @@ func (s *Store) WriteTitle(title string) (Settings, error) { // ReadLogo renvoie le logo PNG 64x64, ou ErrNotFound. func (s *Store) ReadLogo() ([]byte, error) { + if s.cat != nil { + ctx, cancel := ctxOp() + defer cancel() + b, _, err := s.cat.db.GetBlob(ctx, s.cat.logoKey()) + if err == nil && b == nil { + err = ErrNotFound + } + return b, err + } b, err := os.ReadFile(filepath.Join(s.root, logoFile)) return b, mapErr(err) } @@ -348,7 +397,13 @@ func (s *Store) WriteLogo(data []byte) (Settings, error) { if err := png.Encode(&buf, squareResize(img, LogoSize)); err != nil { return Settings{}, err } - if err := atomicWrite(filepath.Join(s.root, logoFile), buf.Bytes()); err != nil { + if s.cat != nil { + ctx, cancel := ctxOp() + defer cancel() + if err := s.cat.db.PutBlob(ctx, s.cat.logoKey(), buf.Bytes()); err != nil { + return Settings{}, err + } + } else if err := atomicWrite(filepath.Join(s.root, logoFile), buf.Bytes()); err != nil { return Settings{}, err } return s.ReadSettings() @@ -356,6 +411,14 @@ func (s *Store) WriteLogo(data []byte) (Settings, error) { // DeleteLogo supprime le logo (sans erreur s'il est absent). func (s *Store) DeleteLogo() (Settings, error) { + if s.cat != nil { + ctx, cancel := ctxOp() + defer cancel() + if err := s.cat.db.PutBlob(ctx, s.cat.logoKey(), nil); err != nil { + return Settings{}, err + } + return s.ReadSettings() + } if err := os.Remove(filepath.Join(s.root, logoFile)); err != nil && !errors.Is(err, fs.ErrNotExist) { return Settings{}, err } diff --git a/internal/storage/share.go b/internal/storage/share.go index ed3b587..a92a44e 100644 --- a/internal/storage/share.go +++ b/internal/storage/share.go @@ -70,12 +70,36 @@ type shareDisk struct { var b64 = base64.RawURLEncoding -// SetShareSecret impose la clé de signature (variable SHARE_SECRET). -func (s *Store) SetShareSecret(secret string) { +// SetShareSecret impose la clé de signature (variable SHARE_SECRET). La +// forme « hex: » reprend le contenu d'un ancien fichier .share-secret, +// ce qui garde valides les liens déjà diffusés. +func (s *Store) SetShareSecret(secret string) error { + key, err := DecodeSecret(secret) + if err != nil { + return err + } s.sharesMu.Lock() defer s.sharesMu.Unlock() - s.shareKey = []byte(secret) + s.shareKey = key s.fixedKey = true + return nil +} + +// DecodeSecret lit une clé fournie par l'environnement : texte brut de 16 +// caractères au moins, ou « hex: » (32 octets au moins) reprise d'un +// fichier de clé généré par Upandown. +func DecodeSecret(secret string) ([]byte, error) { + if h, ok := strings.CutPrefix(secret, "hex:"); ok { + k, err := hex.DecodeString(strings.TrimSpace(h)) + if err != nil || len(k) < 32 { + return nil, errors.New("clé hex: invalide (64 caractères hexadécimaux attendus)") + } + return k, nil + } + if len(secret) < 16 { + return nil, errors.New("clé trop courte (16 caractères minimum)") + } + return []byte(secret), nil } // key renvoie la clé de signature, créée au besoin ; appelé sous sharesMu. diff --git a/internal/tokens/tokens.go b/internal/tokens/tokens.go index ad227ce..8f25491 100644 --- a/internal/tokens/tokens.go +++ b/internal/tokens/tokens.go @@ -4,8 +4,9 @@ // 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. +// (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 ( @@ -16,6 +17,8 @@ import ( "encoding/hex" "encoding/json" "errors" + "fmt" + "log/slog" "net/http" "os" "path/filepath" @@ -25,7 +28,9 @@ import ( "time" "unicode/utf8" + "github.com/jackc/pgx/v5" "github.com/vblogio/upandown/internal/auth" + "github.com/vblogio/upandown/internal/catalog" ) const ( @@ -64,35 +69,129 @@ 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. +// 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 []*Token + 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)} + 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: - var d struct { - Tokens []*Token `json:"tokens"` - } - if err := json.Unmarshal(b, &d); err != nil { + list, err := decode(b) + if err != nil { return nil, errors.New(s.file + " invalide : " + err.Error()) } - s.tokens = d.Tokens + s.tokens = list } return s, nil } -func (s *Store) save() error { - b, err := json.Marshal(map[string]any{"tokens": s.tokens}) +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 } @@ -132,22 +231,23 @@ func (s *Store) Create(userID, name string) (string, Info, error) { 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] + 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 @@ -155,10 +255,12 @@ func (s *Store) Create(userID, name string) (string, Info, error) { // 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() + m, err := s.snapshot() + if err != nil { + slog.Error("jetons : lecture", "err", err) + } out := []Info{} - for _, t := range s.tokens { + for _, t := range m { if t.UserID == userID { out = append(out, t.info()) } @@ -169,30 +271,27 @@ func (s *Store) List(userID string) []Info { // 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 s.update(func(m map[string]*Token) error { + if t, ok := m[id]; !ok || t.UserID != userID { + return ErrNotFound } - } - 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) { - 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) + err := s.update(func(m map[string]*Token) error { + for id, t := range m { + if t.UserID == userID { + delete(m, id) + } } - } - if len(kept) != len(s.tokens) { - s.tokens = kept - _ = s.save() + return nil + }) + if err != nil { + slog.Error("jetons : révocation", "user", userID, "err", err) } } @@ -202,13 +301,35 @@ func (s *Store) Lookup(secret string) (Token, bool) { 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 { - t.LastUsed = time.Now().UTC().Truncate(time.Second) - _ = s.save() + 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 } diff --git a/internal/tokens/tokens_test.go b/internal/tokens/tokens_test.go new file mode 100644 index 0000000..025a705 --- /dev/null +++ b/internal/tokens/tokens_test.go @@ -0,0 +1,96 @@ +package tokens + +import ( + "context" + "errors" + "os" + "path/filepath" + "testing" + "time" + + "github.com/vblogio/upandown/internal/catalog" +) + +func TestFileStore(t *testing.T) { + dir := t.TempDir() + s, err := Open(dir) + if err != nil { + t.Fatal(err) + } + secret, info, err := s.Create("alice", "script") + if err != nil { + t.Fatal(err) + } + s2, err := Open(dir) + if err != nil { + t.Fatal(err) + } + if tok, ok := s2.Lookup(secret); !ok || tok.ID != info.ID || tok.LastUsed.IsZero() { + t.Fatalf("rechargement : %v %+v", ok, tok) + } + if err := s2.Revoke("bob", info.ID); !errors.Is(err, ErrNotFound) { + t.Fatalf("révocation par un autre : %v", err) + } + s2.RevokeUser("alice") + if _, ok := s2.Lookup(secret); ok { + t.Error("jeton révoqué encore valide") + } +} + +func TestCatalogStoreShared(t *testing.T) { + dsn := os.Getenv("UPANDOWN_TEST_DATABASE_URL") + if dsn == "" { + t.Skip("UPANDOWN_TEST_DATABASE_URL non défini") + } + ctx := context.Background() + db, err := catalog.Open(ctx, dsn, 5*time.Second) + if err != nil { + t.Fatal(err) + } + defer db.Close() + if _, err := db.Pool.Exec(ctx, "TRUNCATE tokens; DELETE FROM imports WHERE root = 'global' AND kind = 'tokens'"); err != nil { + t.Fatal(err) + } + // Un ancien fichier est repris au premier branchement. + dir := t.TempDir() + old, _ := Open(dir) + oldSecret, _, _ := old.Create("alice", "ancien") + open := func(dir string) *Store { + s, err := Open(dir) + if err != nil { + t.Fatal(err) + } + if err := s.UseCatalog(db); err != nil { + t.Fatal(err) + } + return s + } + a, b := open(dir), open(t.TempDir()) + if _, err := os.Stat(filepath.Join(dir, fileName+".imported")); err != nil { + t.Fatal("fichier non renommé") + } + if _, ok := b.Lookup(oldSecret); !ok { + t.Fatal("jeton repris introuvable") + } + secret, info, err := a.Create("bob", "ci") + if err != nil { + t.Fatal(err) + } + tok, ok := b.Lookup(secret) + if !ok || tok.UserID != "bob" { + t.Fatalf("lookup sur l'autre instance : %v %+v", ok, tok) + } + if l := a.List("bob"); len(l) != 1 || l[0].LastUsed.IsZero() { + t.Fatalf("liste : %+v", l) + } + if err := b.Revoke("bob", info.ID); err != nil { + t.Fatal(err) + } + if _, ok := a.Lookup(secret); ok { + t.Error("jeton révoqué encore valide") + } + a.RevokeUser("alice") + if _, ok := b.Lookup(oldSecret); ok { + t.Error("RevokeUser sans effet") + } +}