Files

429 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) {
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()
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
}