- Hors liste blanche, reniflage du contenu (UTF-8 valide, sans NUL, peu de caractères de contrôle) : .pem, .csr, fichiers sans extension... servis en text/plain avec les mêmes protections - Langage deviné côté client (highlight.js), sauf blocs PEM/PGP - Paramètres > Aperçu : préférences d'affichage par navigateur (coloration, numéros de ligne, retour à la ligne, Markdown rendu/source, CSV) ; réglages administrateur (détection, plafond 1-50 Mo, extensions texte, extensions exclues, aperçu dans les partages) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
305 lines
9.4 KiB
Go
305 lines
9.4 KiB
Go
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
|
|
}
|