- Nouveau paquet internal/catalog : pool pgx, migrations SQL embarquées (sérialisées entre instances par verrou consultatif), transactions rejouées après conflit, interblocage ou bascule du primaire (pool vidé sur erreur de lecture seule ou de connexion). DSN multi-hôtes accepté (target_session_attrs=read-write) pour une future HA. - Store.UseCatalog : tags, icônes, auteurs (item_meta) et liens de partage (shares) lus et écrits en base ; chaque modification se fait sous verrou consultatif par racine (« main », « home/<id> »), donc sans perte d'écriture entre instances. Sans DATABASE_URL, rien ne change (JSON). - Reprise unique de .meta.json et .shares.json au premier branchement (table imports), fichiers renommés en *.imported. - Serveur : DATABASE_URL / DATABASE_URL_FILE, DATABASE_WAIT (60 s). - Compose : service postgres:16 sur un réseau interne dédié ; Traefik inchangé. Dockerfile : go.sum et téléchargement des modules. - Tests : UPANDOWN_TEST_DATABASE_URL fait passer toute la suite storage par la base ; tests de partage entre deux instances et de reprise JSON. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
435 lines
11 KiB
Go
435 lines
11 KiB
Go
package storage
|
|
|
|
import (
|
|
"crypto/hmac"
|
|
"crypto/pbkdf2"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"crypto/subtle"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// Partage en lecture seule : un lien /s/<jeton> donne accès à un fichier ou à
|
|
// un dossier (navigation et téléchargement) sans authentification, avec un mot
|
|
// de passe facultatif. Le jeton est <id>.<signature> : id aléatoire (128 bits)
|
|
// et HMAC-SHA256 de l'id par la clé du serveur. Un lien est valide si sa
|
|
// signature est correcte, si son id figure dans .shares.json (révocation
|
|
// lien par lien) et s'il n'a pas expiré. Changer de clé (RevokeAllShares)
|
|
// invalide tous les liens d'un coup.
|
|
//
|
|
// Clé : SHARE_SECRET si défini, sinon .share-secret (générée au premier
|
|
// partage, 0600). Le lien suit l'élément s'il est renommé ou déplacé et
|
|
// disparaît s'il est supprimé.
|
|
|
|
const (
|
|
sharesFile = ".shares.json"
|
|
secretFile = ".share-secret"
|
|
shareIDLen = 16 // octets aléatoires
|
|
shareSigLen = 16 // octets de HMAC conservés
|
|
)
|
|
|
|
// Share décrit un lien de partage.
|
|
type Share struct {
|
|
ID string `json:"id"`
|
|
Token string `json:"token"`
|
|
Path string `json:"path"`
|
|
IsDir bool `json:"isDir"`
|
|
Created time.Time `json:"created"`
|
|
Expires *time.Time `json:"expires,omitempty"`
|
|
Protected bool `json:"protected,omitempty"` // protégé par un mot de passe
|
|
Downloads int `json:"downloads,omitempty"` // téléchargements depuis le lien
|
|
|
|
pw string // empreinte du mot de passe (jamais exposée)
|
|
}
|
|
|
|
// ShareOptions règle un nouveau lien : durée de validité (0 : sans expiration)
|
|
// et mot de passe facultatif.
|
|
type ShareOptions struct {
|
|
TTL time.Duration
|
|
Password string
|
|
}
|
|
|
|
type shareDisk struct {
|
|
Path string `json:"path"`
|
|
Created time.Time `json:"created"`
|
|
Expires *time.Time `json:"expires,omitempty"`
|
|
Password string `json:"pw,omitempty"`
|
|
Downloads int `json:"downloads,omitempty"`
|
|
}
|
|
|
|
var b64 = base64.RawURLEncoding
|
|
|
|
// SetShareSecret impose la clé de signature (variable SHARE_SECRET).
|
|
func (s *Store) SetShareSecret(secret string) {
|
|
s.sharesMu.Lock()
|
|
defer s.sharesMu.Unlock()
|
|
s.shareKey = []byte(secret)
|
|
s.fixedKey = true
|
|
}
|
|
|
|
// key renvoie la clé de signature, créée au besoin ; appelé sous sharesMu.
|
|
func (s *Store) key() ([]byte, error) {
|
|
if s.keyFrom != nil {
|
|
return s.keyFrom.lockedKey()
|
|
}
|
|
if s.shareKey != nil {
|
|
return s.shareKey, nil
|
|
}
|
|
p := filepath.Join(s.root, secretFile)
|
|
b, err := os.ReadFile(p)
|
|
if err == nil {
|
|
if k, err := hex.DecodeString(strings.TrimSpace(string(b))); err == nil && len(k) >= 32 {
|
|
s.shareKey = k
|
|
return k, nil
|
|
}
|
|
} else if !errors.Is(err, fs.ErrNotExist) {
|
|
return nil, err
|
|
}
|
|
return s.newKey()
|
|
}
|
|
|
|
// lockedKey renvoie la clé de signature pour un espace personnel.
|
|
func (s *Store) lockedKey() ([]byte, error) {
|
|
s.sharesMu.Lock()
|
|
defer s.sharesMu.Unlock()
|
|
return s.key()
|
|
}
|
|
|
|
func (s *Store) newKey() ([]byte, error) {
|
|
k := make([]byte, 32)
|
|
if _, err := rand.Read(k); err != nil {
|
|
return nil, err
|
|
}
|
|
p := filepath.Join(s.root, secretFile)
|
|
if err := atomicWrite(p, []byte(hex.EncodeToString(k)+"\n")); err != nil {
|
|
return nil, err
|
|
}
|
|
_ = os.Chmod(p, 0o600)
|
|
s.shareKey = k
|
|
return k, nil
|
|
}
|
|
|
|
func sign(key []byte, id string) string {
|
|
m := hmac.New(sha256.New, key)
|
|
m.Write([]byte("upandown-share:" + id))
|
|
return b64.EncodeToString(m.Sum(nil)[:shareSigLen])
|
|
}
|
|
|
|
func (s *Store) readShares() (map[string]shareDisk, error) {
|
|
if s.cat != nil {
|
|
return s.cat.readShares()
|
|
}
|
|
out := map[string]shareDisk{}
|
|
b, err := os.ReadFile(filepath.Join(s.root, sharesFile))
|
|
switch {
|
|
case errors.Is(err, fs.ErrNotExist):
|
|
return out, nil
|
|
case err != nil:
|
|
return nil, err
|
|
}
|
|
var d struct {
|
|
Links map[string]shareDisk `json:"links"`
|
|
}
|
|
if err := json.Unmarshal(b, &d); err != nil {
|
|
return nil, fmt.Errorf("%s : %w", sharesFile, err)
|
|
}
|
|
if d.Links != nil {
|
|
out = d.Links
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (s *Store) writeShares(m map[string]shareDisk) error {
|
|
b, err := json.Marshal(map[string]any{"links": m})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p := filepath.Join(s.root, sharesFile)
|
|
if err := atomicWrite(p, b); err != nil {
|
|
return err
|
|
}
|
|
return os.Chmod(p, 0o600)
|
|
}
|
|
|
|
// editShares applique edit à la liste des liens sous verrou ; edit renvoie
|
|
// false si rien n'a changé (pas d'écriture).
|
|
func (s *Store) editShares(edit func(map[string]shareDisk) (bool, error)) error {
|
|
s.sharesMu.Lock()
|
|
defer s.sharesMu.Unlock()
|
|
if s.cat != nil {
|
|
return s.cat.editShares(edit)
|
|
}
|
|
m, err := s.readShares()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
changed, err := edit(m)
|
|
if err != nil || !changed {
|
|
return err
|
|
}
|
|
return s.writeShares(m)
|
|
}
|
|
|
|
func (s *Store) toShare(key []byte, id string, d shareDisk) Share {
|
|
sh := Share{ID: id, Token: id + "." + sign(key, id), Path: d.Path, Created: d.Created, Expires: d.Expires,
|
|
Protected: d.Password != "", Downloads: d.Downloads, pw: d.Password}
|
|
if fi, err := os.Stat(absOf(s, d.Path)); err == nil {
|
|
sh.IsDir = fi.IsDir()
|
|
}
|
|
return sh
|
|
}
|
|
|
|
// MaxPasswordLen borne le mot de passe d'un lien de partage.
|
|
const MaxPasswordLen = 200
|
|
|
|
// CreateShare crée un lien de partage d'un fichier ou d'un dossier.
|
|
func (s *Store) CreateShare(rel string, o ShareOptions) (Share, error) {
|
|
c, abs, err := s.resolve(rel)
|
|
if err != nil {
|
|
return Share{}, err
|
|
}
|
|
if c == "" {
|
|
return Share{}, ErrInvalidPath
|
|
}
|
|
if fi, err := os.Lstat(abs); err != nil {
|
|
return Share{}, mapErr(err)
|
|
} else if !fi.IsDir() && !fi.Mode().IsRegular() {
|
|
return Share{}, ErrNotFound
|
|
}
|
|
if o.TTL < 0 || len(o.Password) > MaxPasswordLen {
|
|
return Share{}, fmt.Errorf("%w : durée ou mot de passe", ErrInvalidPath)
|
|
}
|
|
raw := make([]byte, shareIDLen)
|
|
if _, err := rand.Read(raw); err != nil {
|
|
return Share{}, err
|
|
}
|
|
id := b64.EncodeToString(raw)
|
|
d := shareDisk{Path: c, Created: time.Now().UTC().Truncate(time.Second)}
|
|
if o.TTL > 0 {
|
|
e := d.Created.Add(o.TTL)
|
|
d.Expires = &e
|
|
}
|
|
if o.Password != "" {
|
|
d.Password = HashSharePassword(o.Password)
|
|
}
|
|
var out Share
|
|
err = s.editShares(func(m map[string]shareDisk) (bool, error) {
|
|
key, err := s.key()
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
m[id] = d
|
|
out = s.toShare(key, id, d)
|
|
return true, nil
|
|
})
|
|
return out, err
|
|
}
|
|
|
|
// Shares liste les liens (d'un schéma, ou tous si rel est vide), les plus
|
|
// récents en premier. Les liens expirés sont purgés au passage.
|
|
func (s *Store) Shares(rel string) ([]Share, error) {
|
|
c := ""
|
|
if rel != "" {
|
|
var err error
|
|
if c, _, err = s.resolve(rel); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
out := []Share{}
|
|
err := s.editShares(func(m map[string]shareDisk) (bool, error) {
|
|
key, err := s.key()
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
purged := false
|
|
for id, d := range m {
|
|
if d.Expires != nil && time.Now().After(*d.Expires) {
|
|
delete(m, id)
|
|
purged = true
|
|
} else if c == "" || d.Path == c {
|
|
out = append(out, s.toShare(key, id, d))
|
|
}
|
|
}
|
|
return purged, nil
|
|
})
|
|
sort.Slice(out, func(i, j int) bool { return out[i].Created.After(out[j].Created) })
|
|
return out, err
|
|
}
|
|
|
|
// RevokeShare supprime un lien.
|
|
func (s *Store) RevokeShare(id string) error {
|
|
return s.editShares(func(m map[string]shareDisk) (bool, error) {
|
|
if _, ok := m[id]; !ok {
|
|
return false, ErrNotFound
|
|
}
|
|
delete(m, id)
|
|
return true, nil
|
|
})
|
|
}
|
|
|
|
// RevokeAllShares supprime tous les liens et change la clé de signature
|
|
// (sauf si elle est imposée par SHARE_SECRET ou reprise du Store principal).
|
|
func (s *Store) RevokeAllShares() error {
|
|
return s.editShares(func(m map[string]shareDisk) (bool, error) {
|
|
clear(m)
|
|
if !s.fixedKey && s.keyFrom == nil {
|
|
if _, err := s.newKey(); err != nil {
|
|
return false, err
|
|
}
|
|
}
|
|
return true, nil
|
|
})
|
|
}
|
|
|
|
// ResolveShare vérifie un jeton et renvoie le lien. Toute anomalie (jeton
|
|
// mal formé, signature fausse, lien révoqué ou expiré) donne ErrNotFound.
|
|
func (s *Store) ResolveShare(token string) (Share, error) {
|
|
id, sig, ok := strings.Cut(token, ".")
|
|
if !ok || len(id) != b64.EncodedLen(shareIDLen) || len(sig) != b64.EncodedLen(shareSigLen) {
|
|
return Share{}, ErrNotFound
|
|
}
|
|
s.sharesMu.Lock()
|
|
defer s.sharesMu.Unlock()
|
|
key, err := s.key()
|
|
if err != nil {
|
|
return Share{}, err
|
|
}
|
|
if subtle.ConstantTimeCompare([]byte(sig), []byte(sign(key, id))) != 1 {
|
|
return Share{}, ErrNotFound
|
|
}
|
|
m, err := s.readShares()
|
|
if err != nil {
|
|
return Share{}, err
|
|
}
|
|
d, ok := m[id]
|
|
if !ok || (d.Expires != nil && time.Now().After(*d.Expires)) {
|
|
return Share{}, ErrNotFound
|
|
}
|
|
return s.toShare(key, id, d), nil
|
|
}
|
|
|
|
// CheckPassword vérifie le mot de passe d'un lien protégé.
|
|
func (sh Share) CheckPassword(pw string) bool {
|
|
return sh.pw != "" && CheckSharePassword(sh.pw, pw)
|
|
}
|
|
|
|
// UnlockCookie renvoie la valeur du cookie qui prouve que le mot de passe du
|
|
// lien a été saisi : HMAC de l'id et de l'empreinte du mot de passe.
|
|
func (s *Store) UnlockCookie(sh Share) (string, error) {
|
|
s.sharesMu.Lock()
|
|
defer s.sharesMu.Unlock()
|
|
key, err := s.key()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
m := hmac.New(sha256.New, key)
|
|
m.Write([]byte("upandown-unlock:" + sh.ID + ":" + sh.pw))
|
|
return b64.EncodeToString(m.Sum(nil)), nil
|
|
}
|
|
|
|
// CountDownload incrémente le compteur de téléchargements d'un lien.
|
|
func (s *Store) CountDownload(id string) {
|
|
_ = s.editShares(func(m map[string]shareDisk) (bool, error) {
|
|
d, ok := m[id]
|
|
if !ok {
|
|
return false, nil
|
|
}
|
|
d.Downloads++
|
|
m[id] = d
|
|
return true, nil
|
|
})
|
|
}
|
|
|
|
// SharedPath joint le chemin partagé et un sous-chemin demandé par le visiteur
|
|
// du lien (vide : l'élément partagé lui-même). Un lien vers un fichier n'accepte
|
|
// pas de sous-chemin ; ".." et les noms cachés sont refusés.
|
|
func SharedPath(sh Share, sub string) (string, error) {
|
|
if sub == "" {
|
|
return sh.Path, nil
|
|
}
|
|
if !sh.IsDir {
|
|
return "", ErrNotFound
|
|
}
|
|
c, err := Clean(sub)
|
|
if err != nil || c == "" {
|
|
return "", ErrNotFound
|
|
}
|
|
return sh.Path + "/" + c, nil
|
|
}
|
|
|
|
// Les opérations suivantes accompagnent Move/Delete.
|
|
|
|
func (s *Store) moveShares(from, to string) {
|
|
_ = s.editShares(func(m map[string]shareDisk) (bool, error) {
|
|
changed := false
|
|
for id, d := range m {
|
|
if under(d.Path, from) {
|
|
d.Path = to + d.Path[len(from):]
|
|
m[id] = d
|
|
changed = true
|
|
}
|
|
}
|
|
return changed, nil
|
|
})
|
|
}
|
|
|
|
func (s *Store) removeShares(c string) {
|
|
_ = s.editShares(func(m map[string]shareDisk) (bool, error) {
|
|
changed := false
|
|
for id, d := range m {
|
|
if under(d.Path, c) {
|
|
delete(m, id)
|
|
changed = true
|
|
}
|
|
}
|
|
return changed, nil
|
|
})
|
|
}
|
|
|
|
// --- Mots de passe de liens -----------------------------------------------------------
|
|
|
|
const sharePwIter = 100_000
|
|
|
|
// HashSharePassword dérive une empreinte PBKDF2-SHA256 « iter$sel$hash ».
|
|
func HashSharePassword(pw string) string {
|
|
salt := make([]byte, 16)
|
|
_, _ = rand.Read(salt)
|
|
return derive(pw, salt, sharePwIter)
|
|
}
|
|
|
|
func derive(pw string, salt []byte, iter int) string {
|
|
h, err := pbkdf2.Key(sha256.New, pw, salt, iter, 32)
|
|
if err != nil {
|
|
panic(err) // paramètres constants valides
|
|
}
|
|
return fmt.Sprintf("%d$%s$%s", iter, b64.EncodeToString(salt), b64.EncodeToString(h))
|
|
}
|
|
|
|
// CheckSharePassword compare un mot de passe à une empreinte HashSharePassword.
|
|
func CheckSharePassword(hash, pw string) bool {
|
|
parts := strings.Split(hash, "$")
|
|
if len(parts) != 3 {
|
|
return false
|
|
}
|
|
iter, err := strconv.Atoi(parts[0])
|
|
if err != nil || iter < 1 || iter > 10_000_000 {
|
|
return false
|
|
}
|
|
salt, err := b64.DecodeString(parts[1])
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return subtle.ConstantTimeCompare([]byte(derive(pw, salt, iter)), []byte(hash)) == 1
|
|
}
|