package api import ( "bytes" "io" "io/fs" "net/http" "os" "path" "strconv" "strings" "unicode/utf8" "github.com/vblogio/upandown/internal/storage" ) // Aperçu en lecture seule, rendu côté client. // // GET /api/preview?path=x (même authentification que /api/file) // GET /api/public/{jeton}/preview?sub=x (même contrôle que /api/public/{jeton}/file) // // Seules les extensions de la liste blanche sont servies, toujours en // Content-Disposition: inline, avec nosniff et une CSP stricte. Le contenu // texte n'est jamais servi avec un type actif (HTML, XML, JavaScript) : un // fichier .html part en text/plain et s'affiche comme du code. Le texte est // plafonné (2 Mo par défaut, réglable) ; au-delà, seul le début est envoyé. // // Hors liste blanche, le contenu est reniflé (sniffText) : un fichier lisible // en texte (.pem, .csr, .crt, fichier sans extension...) est servi en // text/plain avec les mêmes protections, genre "text" et X-Preview-Detected: 1. // Les formats exclus (excludedExts) ne sont jamais reniflés. // // Réglages de l'administrateur (storage.PreviewSettings) : reniflage actif ou // non, plafond du texte, extensions toujours en texte, extensions exclues, // aperçu dans les liens de partage. // // En-têtes de réponse : X-Preview-Kind (text, csv, markdown, code, pdf), // X-Preview-Size (taille réelle du fichier), X-Preview-Truncated (1 si coupé), // X-Preview-Detected (1 si le genre vient du reniflage du contenu). // Genres d'aperçu. const ( PreviewText = "text" PreviewCSV = "csv" PreviewMarkdown = "markdown" PreviewCode = "code" PreviewPDF = "pdf" ) // previewExts : liste blanche des extensions prévisualisables. var previewExts = map[string]string{ ".txt": PreviewText, ".log": PreviewText, ".rst": PreviewText, ".srt": PreviewText, ".sub": PreviewText, ".tex": PreviewText, ".bib": PreviewText, ".nfo": PreviewText, ".csv": PreviewCSV, ".tsv": PreviewCSV, ".md": PreviewMarkdown, ".markdown": PreviewMarkdown, ".pdf": PreviewPDF, } // previewNames : fichiers sans extension reconnus par leur nom (en minuscules). var previewNames = map[string]string{ "dockerfile": PreviewCode, "containerfile": PreviewCode, "makefile": PreviewCode, "jenkinsfile": PreviewCode, "vagrantfile": PreviewCode, "readme": PreviewText, "license": PreviewText, "changelog": PreviewText, } func init() { for _, e := range strings.Fields(` .json .jsonc .js .mjs .cjs .jsx .ts .tsx .yaml .yml .toml .ini .conf .cfg .env .properties .go .py .sh .bash .zsh .ps1 .xml .html .htm .css .scss .less .sql .rs .java .kt .c .h .cpp .hpp .cs .php .rb .lua .tf .hcl .service .gitignore .dockerignore .diff .patch .vue .svelte`) { previewExts[e] = PreviewCode } } // excludedExts : formats texte ou binaires exclus de l'aperçu, même reniflés // (RTF/DOC/DOCX hors périmètre ; SVG servi par /api/file). var excludedExts = map[string]bool{".rtf": true, ".doc": true, ".docx": true, ".svg": true} // PreviewKind renvoie le genre d'aperçu d'un fichier d'après son nom ("" : // hors liste blanche, à renifler sauf extension exclue). func PreviewKind(name string) string { base := strings.ToLower(path.Base(name)) if k, ok := previewNames[base]; ok { return k } // Dockerfile.dev, Containerfile.prod... if strings.HasPrefix(base, "dockerfile.") || strings.HasPrefix(base, "containerfile.") { return PreviewCode } return previewExts[strings.ToLower(path.Ext(base))] } // previewType : type MIME servi pour chaque genre. Jamais de type actif. var previewType = map[string]string{ PreviewText: "text/plain; charset=utf-8", PreviewCode: "text/plain; charset=utf-8", PreviewCSV: "text/csv; charset=utf-8", PreviewMarkdown: "text/markdown; charset=utf-8", PreviewPDF: "application/pdf", } const ( // Texte : récupéré par fetch, jamais affiché en navigation directe comme // un document actif ; sandbox et aucune sous-ressource. cspPreviewText = "sandbox; default-src 'none'; frame-ancestors 'none'" // PDF : affiché par la visionneuse du navigateur dans une iframe de // l'application. Pas de sandbox (Chrome refuse alors d'afficher le PDF). cspPreviewPDF = "default-src 'none'; object-src 'self'; frame-ancestors 'self'" ) func (h *Handler) preview(w http.ResponseWriter, r *http.Request) { u, ok := h.space(w, r) if !ok { return } cfg, ok := h.previewSettings(w) if !ok { return } p := r.URL.Query().Get("path") if cfg.excluded(p) { writeErr(w, http.StatusUnsupportedMediaType, "pas d'aperçu pour ce type de fichier") return } f, fi, err := u.Open(p) if err != nil { fail(w, err) return } defer f.Close() h.servePreview(w, r, f, fi, cfg) } func (h *Handler) publicPreview(w http.ResponseWriter, r *http.Request) { _, st, full, _, ok := h.sharedItem(w, r) if !ok { return } cfg, ok := h.previewSettings(w) if !ok { return } if !cfg.Shares { writeErr(w, http.StatusForbidden, "aperçu désactivé pour les liens de partage") return } f, fi, err := st.Open(full) if err != nil { fail(w, err) return } defer f.Close() h.servePreview(w, r, f, fi, cfg) } // previewConfig : réglages de l'aperçu (paramètres de l'administrateur). type previewConfig struct { storage.PreviewSettings text, excl map[string]bool // extensions avec le point, en minuscules } func (h *Handler) previewSettings(w http.ResponseWriter) (previewConfig, bool) { st, err := h.Store.ReadSettings() if err != nil { fail(w, err) return previewConfig{}, false } c := previewConfig{PreviewSettings: st.Preview, text: map[string]bool{}, excl: map[string]bool{}} for _, e := range st.Preview.TextExts { c.text["."+e] = true } for _, e := range st.Preview.ExcludedExts { c.excl["."+e] = true } return c, true } // excluded : extension exclue d'office (RTF, DOC...) ou par l'administrateur. func (c previewConfig) excluded(name string) bool { e := strings.ToLower(path.Ext(name)) return excludedExts[e] || c.excl[e] } // kind : genre d'après le nom (liste blanche, puis extensions texte de l'administrateur). func (c previewConfig) kind(name string) string { if k := PreviewKind(name); k != "" { return k } if c.text[strings.ToLower(path.Ext(name))] { return PreviewText } return "" } func (c previewConfig) maxText() int64 { if c.MaxTextMB < 1 { return int64(storage.DefaultPreview.MaxTextMB) << 20 } return int64(c.MaxTextMB) << 20 } func (h *Handler) servePreview(w http.ResponseWriter, r *http.Request, f *os.File, fi fs.FileInfo, cfg previewConfig) { name := fi.Name() kind := cfg.kind(name) if fi.IsDir() || cfg.excluded(name) || (kind == "" && !cfg.Sniff) { writeErr(w, http.StatusUnsupportedMediaType, "pas d'aperçu pour ce type de fichier") return } detected := false if kind == "" { head := make([]byte, sniffLen) n, _ := io.ReadFull(f, head) if !sniffText(head[:n], int64(n) < fi.Size()) { writeErr(w, http.StatusUnsupportedMediaType, "pas d'aperçu pour ce type de fichier") return } if _, err := f.Seek(0, io.SeekStart); err != nil { fail(w, err) return } kind, detected = PreviewText, true } hd := w.Header() hd.Set("Content-Type", previewType[kind]) hd.Set("Content-Disposition", contentDisposition(true, name)) hd.Set("X-Content-Type-Options", "nosniff") hd.Set("Cache-Control", "private, no-cache") hd.Set("ETag", storage.ETag(fi)) hd.Set("X-Preview-Kind", kind) hd.Set("X-Preview-Size", strconv.FormatInt(fi.Size(), 10)) hd.Set("X-Preview-Detected", map[bool]string{true: "1", false: "0"}[detected]) if kind == PreviewPDF { hd.Set("Content-Security-Policy", cspPreviewPDF) hd.Set("X-Preview-Truncated", "0") http.ServeContent(w, r, name, fi.ModTime(), f) return } hd.Set("Content-Security-Policy", cspPreviewText) max := cfg.maxText() if h.PreviewMaxText > 0 { // tests max = h.PreviewMaxText } b, err := io.ReadAll(io.LimitReader(f, max)) if err != nil { fail(w, err) return } truncated := fi.Size() > int64(len(b)) if truncated { b = trimPartialRune(b) } if bytes.IndexByte(b[:min(len(b), 8192)], 0) >= 0 { hd.Del("Content-Disposition") writeErr(w, http.StatusUnsupportedMediaType, "contenu binaire : pas d'aperçu") return } hd.Set("X-Preview-Truncated", map[bool]string{true: "1", false: "0"}[truncated]) // L'ETag désigne le fichier : il reste valable pour l'extrait tant que le // plafond ne change pas. Pas de Range sur un extrait. r.Header.Del("Range") http.ServeContent(w, r, name, fi.ModTime(), bytes.NewReader(b)) } // sniffLen : octets examinés pour reconnaître un fichier texte. const sniffLen = 8192 // sniffText indique si un début de fichier est du texte lisible : UTF-8 valide // (un caractère coupé en fin d'échantillon est toléré si partial), aucun octet // NUL, et au plus 1 % de caractères de contrôle hors \t \n \r \f et ESC. // Un fichier vide est du texte. func sniffText(b []byte, partial bool) bool { if partial { b = trimPartialRune(b) } if !utf8.Valid(b) || bytes.IndexByte(b, 0) >= 0 { return false } ctrl := 0 for _, c := range b { if (c < 0x20 && c != '\t' && c != '\n' && c != '\r' && c != '\f' && c != 0x1b) || c == 0x7f { ctrl++ } } return ctrl*100 <= len(b) } // trimPartialRune retire un caractère UTF-8 coupé en fin d'extrait. func trimPartialRune(b []byte) []byte { for i := 1; i <= utf8.UTFMax && i <= len(b); i++ { c := b[len(b)-i] if c < 0x80 { // ASCII : rien de coupé return b } if utf8.RuneStart(c) { if r, _ := utf8.DecodeRune(b[len(b)-i:]); r == utf8.RuneError { return b[:len(b)-i] } return b } } return b }