- 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
459 lines
12 KiB
Go
459 lines
12 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). La
|
|
// forme « hex:<clé> » 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 = key
|
|
s.fixedKey = true
|
|
return nil
|
|
}
|
|
|
|
// DecodeSecret lit une clé fournie par l'environnement : texte brut de 16
|
|
// caractères au moins, ou « hex:<clé> » (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.
|
|
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
|
|
}
|