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/ 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 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: » 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: » (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 }