Up And Down : première version

This commit is contained in:
cedric committed 2026-11-19 10:30:47 +01:00
commit 89c5430308
76 files changed
+20730

No files matched your search

+336
View File
@@ -0,0 +1,336 @@
// 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)
}
}