package storage import ( "bytes" "encoding/json" "errors" "fmt" "image" "image/draw" "image/png" "io/fs" "os" "path/filepath" "strconv" "strings" "unicode/utf8" ) // Paramètres partagés par tous les navigateurs : .settings.json et .logo.png à // la racine. Les valeurs que l'administrateur n'a pas modifiées viennent des // variables d'environnement (SettingsDefaults). const ( settingsFile = ".settings.json" logoFile = ".logo.png" // LogoSize est le côté du logo enregistré (carré, affiché en rond). LogoSize = 64 // MaxLogoUpload borne la taille d'un PNG envoyé avant redimensionnement. MaxLogoUpload = 5 << 20 // MaxTitleLen borne la longueur du titre (en caractères). MaxTitleLen = 80 // MaxTrashDays borne la durée de conservation de la corbeille (en jours). MaxTrashDays = 3650 // MaxQuotaMB borne le quota par utilisateur (Mo). MaxQuotaMB = 100 << 20 maxLogoSide = 8192 // protège contre les « bombes » de décompression ) // ErrInvalidImage signale un logo illisible ou hors limites. var ErrInvalidImage = errors.New("image invalide") // Modes d'inscription (Settings.Registration). const ( RegClosed = "closed" // pas d'inscription : l'administrateur crée les comptes RegApproval = "approval" // inscription libre, compte à valider par un administrateur RegOpen = "open" // inscription libre, compte actif tout de suite ) // ValidRegistration indique si m est un mode d'inscription connu. func ValidRegistration(m string) bool { return m == RegClosed || m == RegApproval || m == RegOpen } // SettingsDefaults : valeurs des paramètres tant qu'ils n'ont pas été modifiés. type SettingsDefaults struct { Registration string // closed, approval ou open QuotaMB int64 // quota de l'espace personnel par utilisateur (0 : illimité) CommonReadonly bool // arborescence commune en lecture seule pour les non-administrateurs TrashDays int } // DefaultSettings : inscription fermée, pas de quota, commun ouvert en écriture. var DefaultSettings = SettingsDefaults{Registration: RegClosed} // Settings est l'état exposé au client. Logo vaut "" sans logo, sinon une // version (date) à ajouter à l'URL pour invalider le cache navigateur. // TrashDays : durée de conservation de la corbeille (0 : jusqu'à ce qu'on la // vide). QuotaMB : quota de l'espace personnel (0 : illimité). type Settings struct { Title string `json:"title"` Logo string `json:"logo"` TrashDays int `json:"trashDays"` Registration string `json:"registration"` QuotaMB int64 `json:"quotaMB"` CommonReadonly bool `json:"commonReadonly"` Preview PreviewSettings `json:"preview"` } // PreviewSettings : réglages de l'aperçu des fichiers (/api/preview). type PreviewSettings struct { // Sniff : un fichier hors liste blanche est prévisualisé si son contenu est // du texte lisible (.pem, .csr, fichiers sans extension...). Sniff bool `json:"sniff"` // MaxTextMB : plafond du texte servi (au-delà, seul le début est affiché). MaxTextMB int `json:"maxTextMB"` // TextExts : extensions toujours affichées en texte, sans reniflage. TextExts []string `json:"textExts"` // ExcludedExts : extensions jamais prévisualisées. ExcludedExts []string `json:"excludedExts"` // Shares : aperçu texte et PDF dans les liens de partage. Shares bool `json:"shares"` } // Bornes des réglages de l'aperçu. const ( MaxPreviewTextMB = 50 maxPreviewExts = 100 maxPreviewExtLen = 16 ) // DefaultPreview : reniflage actif, 2 Mo de texte, aperçu dans les partages. var DefaultPreview = PreviewSettings{Sniff: true, MaxTextMB: 2, TextExts: []string{}, ExcludedExts: []string{}, Shares: true} // previewDisk : champs absents = valeur par défaut. type previewDisk struct { Sniff *bool `json:"sniff,omitempty"` MaxTextMB *int `json:"maxTextMB,omitempty"` TextExts []string `json:"textExts,omitempty"` ExcludedExts []string `json:"excludedExts,omitempty"` Shares *bool `json:"shares,omitempty"` } // PreviewPatch : seuls les champs non nil sont modifiés. type PreviewPatch struct { Sniff *bool `json:"sniff"` MaxTextMB *int `json:"maxTextMB"` TextExts *[]string `json:"textExts"` ExcludedExts *[]string `json:"excludedExts"` Shares *bool `json:"shares"` } type settingsDisk struct { Preview *previewDisk `json:"preview,omitempty"` Title string `json:"title"` TrashDays *int `json:"trashDays,omitempty"` Registration *string `json:"registration,omitempty"` QuotaMB *int64 `json:"quotaMB,omitempty"` CommonReadonly *bool `json:"commonReadonly,omitempty"` } func (s *Store) readSettingsDisk() (settingsDisk, error) { var d settingsDisk b, err := os.ReadFile(filepath.Join(s.root, settingsFile)) switch { case errors.Is(err, fs.ErrNotExist): case err != nil: return d, err default: if err := json.Unmarshal(b, &d); err != nil { return d, fmt.Errorf("%s : %w", settingsFile, err) } } return d, nil } // updateSettings applique edit au fichier de paramètres (lecture, modification, // écriture atomique) sous le verrou du Store. func (s *Store) updateSettings(edit func(*settingsDisk)) (Settings, error) { s.settingsMu.Lock() defer s.settingsMu.Unlock() d, err := s.readSettingsDisk() if err != nil { return Settings{}, err } edit(&d) b, err := json.Marshal(d) if err != nil { return Settings{}, err } if err := atomicWrite(filepath.Join(s.root, settingsFile), b); err != nil { return Settings{}, err } return s.readSettings() } // ReadSettings renvoie les paramètres courants (valeurs par défaut si absents). func (s *Store) ReadSettings() (Settings, error) { s.settingsMu.Lock() defer s.settingsMu.Unlock() return s.readSettings() } func (s *Store) readSettings() (Settings, error) { d, err := s.readSettingsDisk() if err != nil { return Settings{}, err } def := s.Defaults if !ValidRegistration(def.Registration) { def.Registration = RegClosed } st := Settings{Title: d.Title, TrashDays: def.TrashDays, Registration: def.Registration, QuotaMB: def.QuotaMB, CommonReadonly: def.CommonReadonly} if d.TrashDays != nil { st.TrashDays = *d.TrashDays } if d.Registration != nil && ValidRegistration(*d.Registration) { st.Registration = *d.Registration } if d.QuotaMB != nil { st.QuotaMB = *d.QuotaMB } if d.CommonReadonly != nil { st.CommonReadonly = *d.CommonReadonly } st.Preview = DefaultPreview if p := d.Preview; p != nil { if p.Sniff != nil { st.Preview.Sniff = *p.Sniff } if p.MaxTextMB != nil && *p.MaxTextMB >= 1 && *p.MaxTextMB <= MaxPreviewTextMB { st.Preview.MaxTextMB = *p.MaxTextMB } if p.TextExts != nil { st.Preview.TextExts = p.TextExts } if p.ExcludedExts != nil { st.Preview.ExcludedExts = p.ExcludedExts } if p.Shares != nil { st.Preview.Shares = *p.Shares } } if fi, err := os.Stat(filepath.Join(s.root, logoFile)); err == nil { st.Logo = strconv.FormatInt(fi.ModTime().UnixNano(), 36) } return st, nil } // WriteTrashDays règle la purge automatique de la corbeille (0 : désactivée). func (s *Store) WriteTrashDays(days int) (Settings, error) { if days < 0 || days > MaxTrashDays { return Settings{}, fmt.Errorf("%w : durée de 0 à %d jours", ErrInvalidPath, MaxTrashDays) } return s.updateSettings(func(d *settingsDisk) { d.TrashDays = &days }) } // WriteRegistration choisit le mode d'inscription (closed, approval, open). func (s *Store) WriteRegistration(mode string) (Settings, error) { if !ValidRegistration(mode) { return Settings{}, fmt.Errorf("%w : mode d'inscription %q", ErrInvalidPath, mode) } return s.updateSettings(func(d *settingsDisk) { d.Registration = &mode }) } // WriteQuota règle le quota de l'espace personnel en Mo (0 : illimité). func (s *Store) WriteQuota(mb int64) (Settings, error) { if mb < 0 || mb > MaxQuotaMB { return Settings{}, fmt.Errorf("%w : quota invalide", ErrInvalidPath) } return s.updateSettings(func(d *settingsDisk) { d.QuotaMB = &mb }) } // WriteCommonReadonly règle l'accès en écriture à l'arborescence commune. func (s *Store) WriteCommonReadonly(ro bool) (Settings, error) { return s.updateSettings(func(d *settingsDisk) { d.CommonReadonly = &ro }) } // WritePreview modifie les réglages de l'aperçu (champs non nil seulement). // Les extensions sont normalisées : minuscules, sans point, [a-z0-9_+-]. func (s *Store) WritePreview(p PreviewPatch) (Settings, error) { if p.MaxTextMB != nil && (*p.MaxTextMB < 1 || *p.MaxTextMB > MaxPreviewTextMB) { return Settings{}, fmt.Errorf("%w : plafond de 1 à %d Mo", ErrInvalidPath, MaxPreviewTextMB) } var text, excl []string var err error if p.TextExts != nil { if text, err = NormalizeExts(*p.TextExts); err != nil { return Settings{}, err } } if p.ExcludedExts != nil { if excl, err = NormalizeExts(*p.ExcludedExts); err != nil { return Settings{}, err } } return s.updateSettings(func(d *settingsDisk) { if d.Preview == nil { d.Preview = &previewDisk{} } if p.Sniff != nil { d.Preview.Sniff = p.Sniff } if p.MaxTextMB != nil { d.Preview.MaxTextMB = p.MaxTextMB } if p.TextExts != nil { d.Preview.TextExts = text } if p.ExcludedExts != nil { d.Preview.ExcludedExts = excl } if p.Shares != nil { d.Preview.Shares = p.Shares } }) } // NormalizeExts nettoie une liste d'extensions (« .PEM », « crt »...) : minuscules, // sans point, sans doublon ; refuse les caractères hors [a-z0-9_+-]. func NormalizeExts(in []string) ([]string, error) { out := []string{} seen := map[string]bool{} for _, e := range in { e = strings.TrimPrefix(strings.ToLower(strings.TrimSpace(e)), ".") if e == "" || seen[e] { continue } if len(e) > maxPreviewExtLen || strings.IndexFunc(e, func(r rune) bool { return !(r >= 'a' && r <= 'z' || r >= '0' && r <= '9' || r == '_' || r == '+' || r == '-') }) >= 0 { return nil, fmt.Errorf("%w : extension %q", ErrInvalidPath, e) } seen[e] = true out = append(out, e) } if len(out) > maxPreviewExts { return nil, fmt.Errorf("%w : %d extensions au plus", ErrInvalidPath, maxPreviewExts) } return out, nil } // WriteTitle enregistre le titre affiché ("" = titre par défaut). func (s *Store) WriteTitle(title string) (Settings, error) { title = strings.TrimSpace(title) if !utf8.ValidString(title) || strings.ContainsAny(title, "\r\n\x00") { return Settings{}, fmt.Errorf("%w : titre", ErrInvalidPath) } if utf8.RuneCountInString(title) > MaxTitleLen { return Settings{}, fmt.Errorf("%w : titre de %d caractères max", ErrInvalidPath, MaxTitleLen) } return s.updateSettings(func(d *settingsDisk) { d.Title = title }) } // ReadLogo renvoie le logo PNG 64x64, ou ErrNotFound. func (s *Store) ReadLogo() ([]byte, error) { b, err := os.ReadFile(filepath.Join(s.root, logoFile)) return b, mapErr(err) } // WriteLogo décode un PNG, le recadre au centre en carré, le ramène à // LogoSize x LogoSize et l'enregistre (ré-encodé : aucune donnée annexe du // fichier d'origine n'est conservée). func (s *Store) WriteLogo(data []byte) (Settings, error) { cfg, err := png.DecodeConfig(bytes.NewReader(data)) if err != nil { return Settings{}, fmt.Errorf("%w : PNG attendu", ErrInvalidImage) } if cfg.Width < 1 || cfg.Height < 1 || cfg.Width > maxLogoSide || cfg.Height > maxLogoSide { return Settings{}, fmt.Errorf("%w : %dx%d px max", ErrInvalidImage, maxLogoSide, maxLogoSide) } img, err := png.Decode(bytes.NewReader(data)) if err != nil { return Settings{}, fmt.Errorf("%w : PNG illisible", ErrInvalidImage) } var buf bytes.Buffer if err := png.Encode(&buf, squareResize(img, LogoSize)); err != nil { return Settings{}, err } if err := atomicWrite(filepath.Join(s.root, logoFile), buf.Bytes()); err != nil { return Settings{}, err } return s.ReadSettings() } // DeleteLogo supprime le logo (sans erreur s'il est absent). func (s *Store) DeleteLogo() (Settings, error) { if err := os.Remove(filepath.Join(s.root, logoFile)); err != nil && !errors.Is(err, fs.ErrNotExist) { return Settings{}, err } return s.ReadSettings() } // squareResize recadre img au centre (carré) puis le rééchantillonne en n x n // par moyenne de surface (filtre « boîte » pondéré), en alpha prémultiplié // pour éviter les franges sombres sur les bords transparents. func squareResize(img image.Image, n int) *image.RGBA { b := img.Bounds() side := min(b.Dx(), b.Dy()) crop := image.Rect(0, 0, side, side).Add(b.Min). Add(image.Pt((b.Dx()-side)/2, (b.Dy()-side)/2)) src := image.NewRGBA(image.Rect(0, 0, side, side)) draw.Draw(src, src.Bounds(), img, crop.Min, draw.Src) w := boxWeights(side, n) dst := image.NewRGBA(image.Rect(0, 0, n, n)) for dy := 0; dy < n; dy++ { for dx := 0; dx < n; dx++ { var acc [4]float64 var total float64 for _, wy := range w[dy] { row := wy.i * src.Stride for _, wx := range w[dx] { k := wy.w * wx.w p := src.Pix[row+wx.i*4:] for c := range acc { acc[c] += k * float64(p[c]) } total += k } } o := dst.PixOffset(dx, dy) for c := range acc { dst.Pix[o+c] = uint8(acc[c]/total + 0.5) } } } return dst } type weight struct { i int w float64 } // boxWeights calcule, pour chaque pixel cible, les pixels source qu'il couvre // et la fraction couverte. Fonctionne aussi en agrandissement (côté < n). func boxWeights(side, n int) [][]weight { scale := float64(side) / float64(n) out := make([][]weight, n) for d := range out { lo, hi := float64(d)*scale, float64(d+1)*scale for i := int(lo); i < side && float64(i) < hi; i++ { w := min(hi, float64(i+1)) - max(lo, float64(i)) if w > 0 { out[d] = append(out[d], weight{i, w}) } } } return out }