Up And Down : première version
This commit is contained in:
commit
89c5430308
76 files changed
+20730
No files matched your search
@@ -0,0 +1,428 @@
|
||||
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
|
||||
}
|
||||
Reference in new issue
Block a user