Aperçu : route /api/preview en lecture seule et visualiseurs côté client

- GET /api/preview?path= et /api/public/{jeton}/preview : liste blanche d'extensions, inline, nosniff, CSP stricte, texte plafonné à 2 Mo
- Visualiseurs : texte brut, CSV paginé (PapaParse), Markdown sans HTML brut (react-markdown + remark-gfm), code colorisé (highlight.js), PDF natif
- Le HTML s'affiche comme du code, jamais rendu ; RTF/DOC/DOCX hors périmètre

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
cedricandClaude Opus 5.5 committed 2026-11-20 12:02:19 +01:00
1 parent fe81055421
commit d4da3db132
14 files changed
+2378 -39

No files matched your search

+196
View File
@@ -0,0 +1,196 @@
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é à Handler.PreviewMaxText ; au-delà, seul le début est envoyé.
//
// 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é).
// Genres d'aperçu.
const (
PreviewText = "text"
PreviewCSV = "csv"
PreviewMarkdown = "markdown"
PreviewCode = "code"
PreviewPDF = "pdf"
)
// DefaultPreviewMaxText : plafond par défaut du texte servi en aperçu.
const DefaultPreviewMaxText = 2 << 20
// 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
}
}
// PreviewKind renvoie le genre d'aperçu d'un fichier ("" : non prévisualisable).
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
}
p := r.URL.Query().Get("path")
if PreviewKind(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)
}
func (h *Handler) publicPreview(w http.ResponseWriter, r *http.Request) {
_, st, full, _, ok := h.sharedItem(w, r)
if !ok {
return
}
f, fi, err := st.Open(full)
if err != nil {
fail(w, err)
return
}
defer f.Close()
h.servePreview(w, r, f, fi)
}
func (h *Handler) servePreview(w http.ResponseWriter, r *http.Request, f *os.File, fi fs.FileInfo) {
name := fi.Name()
kind := PreviewKind(name)
if kind == "" || fi.IsDir() {
writeErr(w, http.StatusUnsupportedMediaType, "pas d'aperçu pour ce type de fichier")
return
}
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))
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 := h.PreviewMaxText
if max <= 0 {
max = DefaultPreviewMaxText
}
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))
}
// 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
}