sonda/internal/api/http/web.go
tgiachi 7acac73dd0 feat(api): serve the web app on / and for its own links, with a strict policy
A GET or HEAD outside /api is a file of the app, or its page for a link inside it (/admin/users). A file that is missing (under assets/ or with an extension) answers 404, never the page, so a missing script is not run as HTML; hidden files and folders are never served; everything else, and any unknown /api address, keeps the JSON 404. The page gets a Content-Security-Policy that allows only its own server (no address, no wildcard, no inline script), nosniff, DENY and no referrer. Hashed assets are cached for good and the page is asked again. With no app in the binary, / says how to build it. The app is an optional dependency, so existing wiring is unchanged.
2026-11-12 15:56:33 +01:00

137 lines
5.1 KiB
Go

package httpapi
import (
"io/fs"
"mime"
"net/http"
"path"
"strconv"
"strings"
"github.com/gin-gonic/gin"
)
// appPolicy is what the page of the web app may load: only things from its own server. No
// address, no wildcard and no inline or eval script, so a page of the app cannot reach another
// host. `style-src-attr` lets the app set `style="..."` on an element (bars and rings); stylesheets
// and scripts still have to come from the server.
const appPolicy = "default-src 'self'; script-src 'self'; style-src 'self'; style-src-attr 'unsafe-inline'; " +
"img-src 'self' data: blob:; media-src 'self' blob:; font-src 'self'; connect-src 'self'; " +
"object-src 'none'; base-uri 'self'; form-action 'self'; frame-ancestors 'none'"
// Files under assets/ have a hash in their name, so a name never means two different files.
const (
assetsDir = "assets"
foreverCache = "public, max-age=31536000, immutable"
askAgainCache = "no-cache"
pageNotBuilt = `<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Sonda</title><body style="font-family:system-ui,sans-serif;max-width:40rem;margin:3rem auto;padding:0 1rem;line-height:1.5"><h1>Sonda</h1><p>The server is running, but the web app is not part of this build.</p><p>Build it with <code>make build</code> (or build the app in <code>web/</code> and then <code>go build -tags webui</code>), or use the Docker image, which has it.</p><p>The API is at <code>/api/v1</code> and its documentation at <a href="/api/docs/">/api/docs/</a>.</p></body></html>`
)
// appHeaders protects the page of the app: it cannot be framed, the browser does not guess content
// types, no address leaves in a Referer, and the policy keeps it to its own server.
func appHeaders(c *gin.Context) {
h := c.Writer.Header()
h.Set("Content-Security-Policy", appPolicy)
h.Set("X-Content-Type-Options", "nosniff")
h.Set("X-Frame-Options", "DENY")
h.Set("Referrer-Policy", "no-referrer")
}
// noRoute answers every address that no API route owns. A GET or HEAD outside /api is the web
// app: a file of it, or, for a link inside the app (/admin/users), its page. Everything else
// keeps the JSON 404 the API has always given, and so does a file that is not there: a script
// that is missing must never come back as the page, which the browser would try to run.
func noRoute(web fs.FS) gin.HandlerFunc {
hasApp := false
if web != nil {
if info, err := fs.Stat(web, "index.html"); err == nil && !info.IsDir() {
hasApp = true
}
}
return func(c *gin.Context) {
urlPath := c.Request.URL.Path
readOnly := c.Request.Method == http.MethodGet || c.Request.Method == http.MethodHead
if !readOnly || urlPath == "/api" || strings.HasPrefix(urlPath, "/api/") {
writeError(c, http.StatusNotFound, "not_found", "no such route")
return
}
appHeaders(c)
if !hasApp {
respond(c, "text/html; charset=utf-8", askAgainCache, []byte(pageNotBuilt))
return
}
name := strings.Trim(urlPath, "/")
if name == "" {
serveIndex(c, web)
return
}
// Hidden files and anything that is not a clean path inside the app are never served.
if hidden(name) || !fs.ValidPath(name) {
writeError(c, http.StatusNotFound, "not_found", "no such file")
return
}
if info, err := fs.Stat(web, name); err == nil && !info.IsDir() {
serveFile(c, web, name)
return
}
// Not a file: under assets/ or with an extension it is a file that is missing; anything else
// is a link inside the app, which the app itself resolves.
if name == assetsDir || strings.HasPrefix(name, assetsDir+"/") || path.Ext(name) != "" {
writeError(c, http.StatusNotFound, "not_found", "no such file")
return
}
serveIndex(c, web)
}
}
// hidden is true when any part of the path starts with a dot (.gitkeep, .env, ..).
func hidden(name string) bool {
for _, part := range strings.Split(name, "/") {
if strings.HasPrefix(part, ".") {
return true
}
}
return false
}
func serveIndex(c *gin.Context, web fs.FS) {
body, err := fs.ReadFile(web, "index.html")
if err != nil {
writeError(c, http.StatusInternalServerError, "internal", "internal error")
return
}
respond(c, "text/html; charset=utf-8", askAgainCache, body)
}
func serveFile(c *gin.Context, web fs.FS, name string) {
body, err := fs.ReadFile(web, name)
if err != nil {
writeError(c, http.StatusNotFound, "not_found", "no such file")
return
}
contentType := mime.TypeByExtension(path.Ext(name))
if contentType == "" {
contentType = http.DetectContentType(body)
}
cache := askAgainCache
if strings.HasPrefix(name, assetsDir+"/") {
cache = foreverCache
}
respond(c, contentType, cache, body)
}
// respond sends a body with its type and cache rule. A HEAD gets the same headers and no body.
func respond(c *gin.Context, contentType, cache string, body []byte) {
h := c.Writer.Header()
h.Set("X-Content-Type-Options", "nosniff")
h.Set("Cache-Control", cache)
h.Set("Content-Type", contentType)
if c.Request.Method == http.MethodHead {
h.Set("Content-Length", strconv.Itoa(len(body)))
c.Status(http.StatusOK)
c.Writer.WriteHeaderNow()
return
}
c.Data(http.StatusOK, contentType, body)
}