clawbot
73b39e485b
check / check (push) Waiting to run
A page on another origin can POST text/plain or a form without a CORS preflight, so its visitors' browsers could store reports although the server sends no CORS headers. decodeJSON now refuses a request whose Content-Type is not application/json (parameters such as charset allowed), and the report handler answers it 415 with the usual error body, storing nothing. A JSON POST waits for the preflight, which only an origin in CORS_ALLOWED_ORIGINS passes; the page already sends application/json. Model: opus-5-5
401 lines
10 KiB
Go
401 lines
10 KiB
Go
package handlers_test
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"sneak.berlin/go/netwatch/internal/handlers"
|
|
"sneak.berlin/go/netwatch/internal/logger"
|
|
"sneak.berlin/go/netwatch/internal/middleware"
|
|
"sneak.berlin/go/netwatch/internal/reportbuf"
|
|
)
|
|
|
|
var errStorageFailed = errors.New("storage failed")
|
|
|
|
// stubAppender drives the storage success/failure path without a
|
|
// real buffer or disk.
|
|
type stubAppender struct {
|
|
err error
|
|
}
|
|
|
|
func (s stubAppender) Append(any) error { return s.err }
|
|
|
|
// recordingAppender keeps every report the handler stores.
|
|
type recordingAppender struct {
|
|
reports []any
|
|
}
|
|
|
|
func (a *recordingAppender) Append(v any) error {
|
|
a.reports = append(a.reports, v)
|
|
|
|
return nil
|
|
}
|
|
|
|
func newTestHandlers(buf stubAppender, out io.Writer) *handlers.Handlers {
|
|
return handlers.NewForTest(buf, slog.New(slog.NewJSONHandler(out, nil)))
|
|
}
|
|
|
|
func decodeStatus(t *testing.T, body []byte) string {
|
|
t.Helper()
|
|
|
|
var resp struct {
|
|
Status string `json:"status"`
|
|
}
|
|
|
|
err := json.Unmarshal(body, &resp)
|
|
if err != nil {
|
|
t.Fatalf("response body not JSON: %v (%q)", err, body)
|
|
}
|
|
|
|
return resp.Status
|
|
}
|
|
|
|
// TestHandleReportAcceptsValidReports checks the answer to a valid
|
|
// report, one with no hosts and one shaped as the frontend sends them:
|
|
// 200 and {"status":"ok"} as JSON.
|
|
func TestHandleReportAcceptsValidReports(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
body string
|
|
}{
|
|
{
|
|
name: "no hosts",
|
|
body: `{"clientId":"c1","geo":null,"hosts":[],` +
|
|
`"timestamp":"2026-10-03T12:00:00.000Z"}`,
|
|
},
|
|
{
|
|
name: "a host with a latency and an error sample",
|
|
body: `{"clientId":"c1","geo":null,"hosts":[{` +
|
|
`"name":"Example","url":"https://example.com/",` +
|
|
`"status":"error","history":[` +
|
|
`{"t":1790000000000,"latency":42,"error":null},` +
|
|
`{"t":1790000003000,"latency":null,"error":"timeout"}]}],` +
|
|
`"timestamp":"2026-10-03T12:00:00.000Z"}`,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
h := newTestHandlers(stubAppender{}, io.Discard)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(tt.body),
|
|
)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want %d", rec.Code, http.StatusOK)
|
|
}
|
|
|
|
contentType := rec.Header().Get("Content-Type")
|
|
if contentType != "application/json; charset=utf-8" {
|
|
t.Errorf("Content-Type = %q, want %q",
|
|
contentType, "application/json; charset=utf-8")
|
|
}
|
|
|
|
if got := rec.Body.String(); got != "{\"status\":\"ok\"}\n" {
|
|
t.Errorf("body = %q, want %q", got, "{\"status\":\"ok\"}\n")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestHandleReportStoresOnlyJSON checks that a report is stored only
|
|
// when sent as application/json, as the page sends it. One sent as
|
|
// text/plain or as a form, which a page on another origin can send
|
|
// without a CORS preflight, is refused with 415.
|
|
func TestHandleReportStoresOnlyJSON(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
contentType string
|
|
wantStatus int
|
|
wantStored int
|
|
}{
|
|
{
|
|
name: "text/plain",
|
|
contentType: "text/plain;charset=UTF-8",
|
|
wantStatus: http.StatusUnsupportedMediaType,
|
|
wantStored: 0,
|
|
},
|
|
{
|
|
name: "a urlencoded form",
|
|
contentType: "application/x-www-form-urlencoded",
|
|
wantStatus: http.StatusUnsupportedMediaType,
|
|
wantStored: 0,
|
|
},
|
|
{
|
|
name: "a multipart form",
|
|
contentType: "multipart/form-data; boundary=x",
|
|
wantStatus: http.StatusUnsupportedMediaType,
|
|
wantStored: 0,
|
|
},
|
|
{
|
|
name: "no Content-Type",
|
|
contentType: "",
|
|
wantStatus: http.StatusUnsupportedMediaType,
|
|
wantStored: 0,
|
|
},
|
|
{
|
|
name: "application/json",
|
|
contentType: "application/json",
|
|
wantStatus: http.StatusOK,
|
|
wantStored: 1,
|
|
},
|
|
{
|
|
name: "application/json with a charset",
|
|
contentType: "application/json;charset=UTF-8",
|
|
wantStatus: http.StatusOK,
|
|
wantStored: 1,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var stored recordingAppender
|
|
|
|
h := handlers.NewForTest(&stored, slog.New(slog.DiscardHandler))
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{"clientId":"c1","hosts":[]}`),
|
|
)
|
|
|
|
if tt.contentType != "" {
|
|
req.Header.Set("Content-Type", tt.contentType)
|
|
}
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != tt.wantStatus {
|
|
t.Errorf("status = %d, want %d", rec.Code, tt.wantStatus)
|
|
}
|
|
|
|
if len(stored.reports) != tt.wantStored {
|
|
t.Errorf("reports stored = %d, want %d",
|
|
len(stored.reports), tt.wantStored)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHandleReportStorageFailureIsNon2xx(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
h := newTestHandlers(stubAppender{err: errStorageFailed}, io.Discard)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{"clientId":"c1","hosts":[]}`),
|
|
)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code < 500 {
|
|
t.Fatalf("storage failure status = %d, want a 5xx", rec.Code)
|
|
}
|
|
|
|
if got := decodeStatus(t, rec.Body.Bytes()); got != "error" {
|
|
t.Fatalf("status field = %q, want %q", got, "error")
|
|
}
|
|
}
|
|
|
|
// TestHandleReportFullIs507 checks the answer when the reports waiting
|
|
// to be written fill the size cap: 507 and the usual error body, which
|
|
// tells the client nothing more.
|
|
func TestHandleReportFullIs507(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
h := newTestHandlers(stubAppender{err: reportbuf.ErrFull}, io.Discard)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{"clientId":"c1","hosts":[]}`),
|
|
)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusInsufficientStorage {
|
|
t.Fatalf("status = %d, want %d",
|
|
rec.Code, http.StatusInsufficientStorage)
|
|
}
|
|
|
|
if got := rec.Body.String(); got != "{\"status\":\"error\"}\n" {
|
|
t.Errorf("body = %q, want %q", got, "{\"status\":\"error\"}\n")
|
|
}
|
|
}
|
|
|
|
func TestHandleReportMalformedJSONIs400(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
h := newTestHandlers(stubAppender{}, io.Discard)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{not json`),
|
|
)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusBadRequest {
|
|
t.Fatalf("malformed status = %d, want %d",
|
|
rec.Code, http.StatusBadRequest)
|
|
}
|
|
}
|
|
|
|
func TestHandleReportOversizeIs413(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const limit = 32
|
|
|
|
h := newTestHandlers(stubAppender{}, io.Discard)
|
|
handler := (&middleware.Middleware{}).MaxBodyBytes(limit)(
|
|
h.HandleReport(),
|
|
)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{"clientId":"`+strings.Repeat("x", 200)+`"}`),
|
|
)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
// No declared length, so only the middleware's read cap can
|
|
// stop this body.
|
|
req.ContentLength = -1
|
|
|
|
handler.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusRequestEntityTooLarge {
|
|
t.Fatalf("oversize status = %d, want %d",
|
|
rec.Code, http.StatusRequestEntityTooLarge)
|
|
}
|
|
}
|
|
|
|
func TestHandleReportDoesNotLogRawGeo(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const sentinel = "SENSITIVE-GEO-BLOB"
|
|
|
|
var logbuf bytes.Buffer
|
|
|
|
h := newTestHandlers(stubAppender{}, &logbuf)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(
|
|
`{"clientId":"c1","geo":{"raw":"`+sentinel+`"},"hosts":[]}`,
|
|
),
|
|
)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want %d", rec.Code, http.StatusOK)
|
|
}
|
|
|
|
if strings.Contains(logbuf.String(), sentinel) {
|
|
t.Fatal("raw geo bytes were written to the log")
|
|
}
|
|
|
|
if !strings.Contains(logbuf.String(), "geo_bytes") {
|
|
t.Fatal("expected a bounded geo_bytes field in the log")
|
|
}
|
|
}
|
|
|
|
func TestHandleReportLogsClientIDCutToBound(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
long := strings.Repeat("c", 2*logger.MaxLoggedFieldBytes)
|
|
|
|
var logbuf bytes.Buffer
|
|
|
|
h := newTestHandlers(stubAppender{}, &logbuf)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(
|
|
`{"clientId":"`+long+`","timestamp":"`+long+`","hosts":[]}`,
|
|
),
|
|
)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
var logged map[string]any
|
|
|
|
err := json.Unmarshal(logbuf.Bytes(), &logged)
|
|
if err != nil {
|
|
t.Fatalf("log line not JSON: %v (%q)", err, logbuf.String())
|
|
}
|
|
|
|
want := long[:logger.MaxLoggedFieldBytes]
|
|
|
|
if logged["client_id"] != want {
|
|
t.Fatalf("logged client_id not cut to %d bytes: %q",
|
|
logger.MaxLoggedFieldBytes, logged["client_id"])
|
|
}
|
|
|
|
if logged["timestamp"] != want {
|
|
t.Fatalf("logged timestamp not cut to %d bytes: %q",
|
|
logger.MaxLoggedFieldBytes, logged["timestamp"])
|
|
}
|
|
}
|
|
|
|
func TestHandleReportDecodeErrorLogIsBounded(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// A number too large for its int64 field makes the decoder's
|
|
// error text quote the whole number.
|
|
huge := strings.Repeat("9", 2*logger.MaxLoggedFieldBytes)
|
|
|
|
var logbuf bytes.Buffer
|
|
|
|
h := newTestHandlers(stubAppender{}, &logbuf)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{"hosts":[{"history":[{"t":`+huge+`}]}]}`),
|
|
)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want %d", rec.Code, http.StatusBadRequest)
|
|
}
|
|
|
|
if strings.Contains(logbuf.String(), huge) {
|
|
t.Fatal("the whole oversized number was written to the log")
|
|
}
|
|
}
|