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 = `
SondaSonda
The server is running, but the web app is not part of this build.
Build it with make build (or build the app in web/ and then go build -tags webui), or use the Docker image, which has it.
The API is at /api/v1 and its documentation at /api/docs/.
`
)
// 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)
}