diff --git a/internal/api/http/router.go b/internal/api/http/router.go
index 4659106..41e517c 100644
--- a/internal/api/http/router.go
+++ b/internal/api/http/router.go
@@ -5,6 +5,7 @@ package httpapi
import (
"context"
+ "io/fs"
"net/http"
"reflect"
"strings"
@@ -158,6 +159,9 @@ type Deps struct {
ArtistImages artistImageService
Settings userSettingsService
Streams streamService
+ // Web is the built web app, served on / and for its own links. It is optional: with none (a build
+ // without the app) / shows a page that says how to build it, and the API works the same.
+ Web fs.FS
}
// missingDeps names the services of d that were not set. Every field but the logger is an
@@ -167,7 +171,7 @@ func missingDeps(d Deps) []string {
v := reflect.ValueOf(d)
for i := 0; i < v.NumField(); i++ {
f := v.Type().Field(i)
- if f.Name == "Logger" {
+ if f.Name == "Logger" || f.Name == "Web" {
continue
}
if v.Field(i).Kind() == reflect.Interface && v.Field(i).IsNil() {
@@ -186,7 +190,7 @@ func NewRouter(d Deps) *gin.Engine {
r := gin.New()
_ = r.SetTrustedProxies(nil) // use the socket address; no forwarded-header trust yet
r.Use(gin.Recovery(), limitBody(maxBodyBytes), requestLog(d.Logger))
- r.NoRoute(func(c *gin.Context) { writeError(c, http.StatusNotFound, "not_found", "no such route") })
+ r.NoRoute(noRoute(d.Web))
v1 := r.Group("/api/v1")
v1.GET("/health", health)
diff --git a/internal/api/http/web.go b/internal/api/http/web.go
new file mode 100644
index 0000000..1a625b0
--- /dev/null
+++ b/internal/api/http/web.go
@@ -0,0 +1,137 @@
+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 = `
Sonda
Sonda
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)
+}
diff --git a/internal/api/http/web_test.go b/internal/api/http/web_test.go
new file mode 100644
index 0000000..c4bf28e
--- /dev/null
+++ b/internal/api/http/web_test.go
@@ -0,0 +1,236 @@
+package httpapi
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+ "testing/fstest"
+)
+
+const indexHTML = `Sonda app`
+
+// theApp is a small built web app: a page, hashed assets, a top-level file, and files that must never be served.
+func theApp() fstest.MapFS {
+ return fstest.MapFS{
+ "index.html": {Data: []byte(indexHTML)},
+ "favicon.svg": {Data: []byte("")},
+ "assets/app-abc123.js": {Data: []byte("console.log('app')")},
+ "assets/app-abc123.css": {Data: []byte("body{margin:0}")},
+ "assets/font-1.woff2": {Data: []byte("font")},
+ "assets/.hidden": {Data: []byte("secret")},
+ ".gitkeep": {Data: []byte("")},
+ }
+}
+
+func serve(t *testing.T, app fstest.MapFS, method, path string) *httptest.ResponseRecorder {
+ t.Helper()
+ h, _ := newTestEnv(t, func(d *Deps) {
+ if app != nil {
+ d.Web = app
+ }
+ })
+ rec := httptest.NewRecorder()
+ h.ServeHTTP(rec, httptest.NewRequest(method, path, nil))
+ return rec
+}
+
+func TestRootServesTheAppWithItsHeaders(t *testing.T) {
+ rec := serve(t, theApp(), http.MethodGet, "/")
+ if rec.Code != http.StatusOK {
+ t.Fatalf("status %d, want 200", rec.Code)
+ }
+ if rec.Body.String() != indexHTML {
+ t.Errorf("body %q is not the page of the app", rec.Body.String())
+ }
+ if ct := rec.Header().Get("Content-Type"); !strings.HasPrefix(ct, "text/html") {
+ t.Errorf("Content-Type %q, want text/html", ct)
+ }
+ if got := rec.Header().Get("Cache-Control"); got != "no-cache" {
+ t.Errorf("Cache-Control %q: the page must be asked again, so that an update shows at once", got)
+ }
+ for header, want := range map[string]string{
+ "X-Content-Type-Options": "nosniff",
+ "X-Frame-Options": "DENY",
+ "Referrer-Policy": "no-referrer",
+ } {
+ if got := rec.Header().Get(header); got != want {
+ t.Errorf("%s = %q, want %q", header, got, want)
+ }
+ }
+ csp := rec.Header().Get("Content-Security-Policy")
+ for _, directive := range []string{
+ "default-src 'self'", "script-src 'self'", "connect-src 'self'", "img-src 'self' data: blob:",
+ "media-src 'self' blob:", "font-src 'self'", "object-src 'none'", "frame-ancestors 'none'",
+ "base-uri 'self'", "form-action 'self'", "style-src 'self'", "style-src-attr 'unsafe-inline'",
+ } {
+ if !strings.Contains(csp, directive) {
+ t.Errorf("the policy %q lacks %q", csp, directive)
+ }
+ }
+ // Nothing in the policy may let the page reach another server.
+ if strings.Contains(csp, "http:") || strings.Contains(csp, "https:") || strings.Contains(csp, "*") {
+ t.Errorf("the policy %q allows resources from outside", csp)
+ }
+ if strings.Contains(csp, "script-src 'self' 'unsafe") || strings.Contains(csp, "'unsafe-eval'") {
+ t.Errorf("the policy %q allows inline or eval scripts", csp)
+ }
+}
+
+func TestDirectLinksOfTheAppServeThePage(t *testing.T) {
+ for _, path := range []string{"/admin/users", "/artists/5", "/search?q=bjork", "/settings"} {
+ rec := serve(t, theApp(), http.MethodGet, path)
+ if rec.Code != http.StatusOK || rec.Body.String() != indexHTML {
+ t.Errorf("GET %s: status %d, body %q; want the page of the app", path, rec.Code, rec.Body.String())
+ }
+ if rec.Header().Get("Content-Security-Policy") == "" {
+ t.Errorf("GET %s: no policy", path)
+ }
+ }
+}
+
+func TestAssetsAreServedWithTheirTypeAndForever(t *testing.T) {
+ cases := map[string]string{
+ "/assets/app-abc123.js": "javascript",
+ "/assets/app-abc123.css": "text/css",
+ "/assets/font-1.woff2": "font/woff2",
+ }
+ for path, wantType := range cases {
+ rec := serve(t, theApp(), http.MethodGet, path)
+ if rec.Code != http.StatusOK {
+ t.Errorf("GET %s: status %d, want 200", path, rec.Code)
+ continue
+ }
+ if ct := rec.Header().Get("Content-Type"); !strings.Contains(ct, wantType) {
+ t.Errorf("GET %s: Content-Type %q, want %q", path, ct, wantType)
+ }
+ if got := rec.Header().Get("Cache-Control"); got != "public, max-age=31536000, immutable" {
+ t.Errorf("GET %s: Cache-Control %q: a file with a hash in its name never changes", path, got)
+ }
+ if rec.Header().Get("X-Content-Type-Options") != "nosniff" {
+ t.Errorf("GET %s: no nosniff", path)
+ }
+ }
+}
+
+func TestATopLevelFileIsServedButAskedAgain(t *testing.T) {
+ rec := serve(t, theApp(), http.MethodGet, "/favicon.svg")
+ if rec.Code != http.StatusOK || !strings.Contains(rec.Header().Get("Content-Type"), "svg") {
+ t.Fatalf("status %d, type %q; want the icon", rec.Code, rec.Header().Get("Content-Type"))
+ }
+ if got := rec.Header().Get("Cache-Control"); got != "no-cache" {
+ t.Errorf("Cache-Control %q: a file with no hash in its name may change", got)
+ }
+}
+
+// A script that is missing must never come back as the HTML page: the browser would try to run it.
+func TestAMissingFileIsA404NotThePage(t *testing.T) {
+ for _, path := range []string{"/assets/nope.js", "/assets/", "/assets", "/missing.js", "/some/deep/missing.css", "/robots.txt"} {
+ rec := serve(t, theApp(), http.MethodGet, path)
+ if rec.Code != http.StatusNotFound {
+ t.Errorf("GET %s: status %d, want 404", path, rec.Code)
+ }
+ if strings.Contains(rec.Body.String(), "Sonda app") {
+ t.Errorf("GET %s: answered with the page of the app", path)
+ }
+ }
+}
+
+func TestHiddenFilesAreNeverServed(t *testing.T) {
+ for _, path := range []string{"/.gitkeep", "/assets/.hidden", "/.env", "/assets/../.gitkeep"} {
+ rec := serve(t, theApp(), http.MethodGet, path)
+ if rec.Code == http.StatusOK && rec.Body.String() != indexHTML {
+ t.Errorf("GET %s: served %q", path, rec.Body.String())
+ }
+ if strings.Contains(rec.Body.String(), "secret") {
+ t.Errorf("GET %s: leaked a hidden file", path)
+ }
+ }
+ if rec := serve(t, theApp(), http.MethodGet, "/assets/.hidden"); rec.Code != http.StatusNotFound {
+ t.Errorf("a hidden file under assets: status %d, want 404", rec.Code)
+ }
+}
+
+func TestHeadWorksAndSendsNoBody(t *testing.T) {
+ rec := serve(t, theApp(), http.MethodHead, "/")
+ if rec.Code != http.StatusOK || rec.Body.Len() != 0 {
+ t.Errorf("HEAD /: status %d with %d bytes", rec.Code, rec.Body.Len())
+ }
+ if rec := serve(t, theApp(), http.MethodHead, "/assets/app-abc123.js"); rec.Code != http.StatusOK {
+ t.Errorf("HEAD of an asset: status %d", rec.Code)
+ }
+}
+
+func TestOtherMethodsOutsideTheAPIAreAJSON404(t *testing.T) {
+ for _, method := range []string{http.MethodPost, http.MethodPut, http.MethodDelete, http.MethodPatch} {
+ rec := serve(t, theApp(), method, "/admin/users")
+ if rec.Code != http.StatusNotFound {
+ t.Errorf("%s /admin/users: status %d, want 404", method, rec.Code)
+ }
+ if !strings.Contains(rec.Body.String(), `"code":"not_found"`) {
+ t.Errorf("%s /admin/users: body %q, want the JSON error", method, rec.Body.String())
+ }
+ }
+}
+
+// The API keeps answering as it did: an unknown address under /api is a JSON 404, never the page.
+func TestUnknownAPIAddressesStayJSON404(t *testing.T) {
+ for _, path := range []string{"/api/v1/not-there", "/api/nothing", "/api"} {
+ rec := serve(t, theApp(), http.MethodGet, path)
+ if rec.Code != http.StatusNotFound {
+ t.Errorf("GET %s: status %d, want 404", path, rec.Code)
+ }
+ if !strings.Contains(rec.Body.String(), `"code":"not_found"`) || strings.Contains(rec.Body.String(), "Sonda app") {
+ t.Errorf("GET %s: body %q, want the JSON error", path, rec.Body.String())
+ }
+ }
+}
+
+func TestTheAPIAndItsDocsAreNotAffected(t *testing.T) {
+ if rec := serve(t, theApp(), http.MethodGet, "/api/v1/health"); rec.Code != http.StatusOK {
+ t.Errorf("health: status %d", rec.Code)
+ }
+ rec := serve(t, theApp(), http.MethodGet, "/api/docs/")
+ if rec.Code != http.StatusOK {
+ t.Fatalf("docs: status %d", rec.Code)
+ }
+ if strings.Contains(rec.Header().Get("Content-Security-Policy"), "default-src") {
+ t.Errorf("the docs page got the policy of the app: %q", rec.Header().Get("Content-Security-Policy"))
+ }
+}
+
+func TestPathsThatTryToLeaveTheAppDoNotBreakAnything(t *testing.T) {
+ for _, path := range []string{"/..%2f..%2fetc%2fpasswd", "/%2e%2e/%2e%2e/etc/passwd", "/assets/..%2f..%2fgo.mod", "/%00"} {
+ rec := serve(t, theApp(), http.MethodGet, path)
+ if rec.Code >= 500 {
+ t.Errorf("GET %s: status %d", path, rec.Code)
+ }
+ if strings.Contains(rec.Body.String(), "root:") || strings.Contains(rec.Body.String(), "module codeberg.org") {
+ t.Errorf("GET %s: left the app", path)
+ }
+ }
+}
+
+// With no app in the binary (a build without the webui tag) / says how to build it, and the API works.
+func TestWithNoAppTheRootSaysHowToBuildIt(t *testing.T) {
+ for name, app := range map[string]fstest.MapFS{"nil": nil, "empty": {}} {
+ for _, path := range []string{"/", "/admin/users"} {
+ rec := serve(t, app, http.MethodGet, path)
+ if rec.Code != http.StatusOK {
+ t.Errorf("%s FS, GET %s: status %d, want 200", name, path, rec.Code)
+ }
+ body := rec.Body.String()
+ for _, want := range []string{"make build", "/api/docs/", "/api/v1"} {
+ if !strings.Contains(body, want) {
+ t.Errorf("%s FS, GET %s: the page does not mention %q", name, path, want)
+ }
+ }
+ if !strings.HasPrefix(rec.Header().Get("Content-Type"), "text/html") {
+ t.Errorf("%s FS: Content-Type %q", name, rec.Header().Get("Content-Type"))
+ }
+ }
+ if rec := serve(t, app, http.MethodGet, "/api/v1/health"); rec.Code != http.StatusOK {
+ t.Errorf("%s FS: the API does not work, status %d", name, rec.Code)
+ }
+ }
+}