server: set ReadTimeout, WriteTimeout, and IdleTimeout (closes #99)

The http.Server literal only set ReadHeaderTimeout. The other three
timeouts defaulted to zero, which in net/http means no limit: past the
header phase a peer could hold a connection open forever, responses had
no write deadline, and keep-alive connections were never reaped.
REPO_POLICIES.md requires all four before 1.0.

All four are now named constants in internal/server/server.go:

  ReadHeaderTimeout  10s  (unchanged)
  ReadTimeout        15s  whole request; every route is a bodyless GET
  WriteTimeout       75s  handler execution plus response flush
  IdleTimeout       120s  keep-alive reaping

WriteTimeout must exceed the 60s chimw.Timeout handler budget in
routes.go. net/http arms the write deadline once the request headers
have been read, so it covers handler execution as well as the response
write; a smaller value would sever the connection before a handler that
legitimately used its full budget could respond, making that budget
unreachable. The 15s difference is the response-flush allowance. The
comment on the const block states this relationship.

IdleTimeout sits above the common Prometheus scrape intervals so the
scraper reuses its connection instead of reconnecting each cycle, while
an abandoned connection is still reaped within two minutes.

The http.Server literal moved into newHTTPServer so the configuration
is testable without binding a socket. Tests assert all four fields are
non-zero, that WriteTimeout exceeds the handler budget, and that
ReadTimeout covers ReadHeaderTimeout; they compare configured values
only and measure no elapsed time, so they cannot flake.

README.md

@@ -182,45 +182,26 @@ dnswatcher exposes a lightweight HTTP API for operational visibility:
 | `GET /api/v1/status`                  | Current monitoring state       |
 | `GET /metrics`                        | Prometheus metrics (optional)  |
 
-### Security Headers
+#### Server timeouts
 
-Every response — the dashboard, the static assets under `/s/...`, the
-healthchecks, the JSON API, and `/metrics` — carries the following
-headers, set by a global middleware:
+The HTTP server sets all four socket-level timeouts. These are compile-time
+constants in `internal/server/server.go`, not configurable via environment
+variables.
 
-| Header                      | Value                                 |
-|-----------------------------|---------------------------------------|
-| `Strict-Transport-Security` | `max-age=31536000; includeSubDomains` |
-| `Content-Security-Policy`   | see below                             |
-| `X-Frame-Options`           | `DENY`                                |
-| `X-Content-Type-Options`    | `nosniff`                             |
-| `Referrer-Policy`           | `no-referrer`                         |
-| `Permissions-Policy`        | all unused browser features denied    |
+| Timeout             | Value | Purpose                                       |
+|---------------------|-------|-----------------------------------------------|
+| `ReadHeaderTimeout` | 10s   | Bounds the request header read (slowloris)    |
+| `ReadTimeout`       | 15s   | Bounds the whole request read, headers + body |
+| `WriteTimeout`      | 75s   | Bounds handler execution plus response flush  |
+| `IdleTimeout`       | 120s  | Reaps idle keep-alive connections             |
 
-The content security policy is:
-
-```
-default-src 'self'; script-src 'none'; style-src 'self'; img-src 'self';
-font-src 'none'; connect-src 'none'; object-src 'none'; base-uri 'none';
-form-action 'none'; frame-ancestors 'none'
-```
-
-The dashboard ships no JavaScript (the 30-second refresh is a
-`<meta http-equiv="refresh">`), no inline styles, no inline event
-handlers, and no images; its only subresource is the embedded stylesheet
-at `/s/css/tailwind.min.css`, which `style-src 'self'` permits. The
-policy therefore needs neither `unsafe-inline` nor `unsafe-eval`.
-`frame-ancestors 'none'` is the primary anti-framing control, with
-`X-Frame-Options: DENY` retained as the legacy fallback.
-
-HSTS is emitted unconditionally, including over plain HTTP. dnswatcher is
-expected to run behind a TLS-terminating reverse proxy, and the browser
-must still be told to enforce HTTPS end to end, so the header is never
-gated on whether the request itself arrived over TLS.
-
-`Referrer-Policy: no-referrer` is stricter than the
-`strict-origin-when-cross-origin` baseline: the dashboard has no
-cross-origin navigation needs, and its URL may name internal hosts.
+These are distinct from the 60s per-request handler budget applied by
+`chimw.Timeout` in `internal/server/routes.go`, which cancels the request
+context but does not touch the socket. `WriteTimeout` is deliberately
+larger than that budget: the write deadline is armed once request headers
+are read, so a smaller value would sever the connection before a handler
+using its full budget could respond. `IdleTimeout` exceeds common
+Prometheus scrape intervals so the scraper reuses its connection.
 
 ---
 
@@ -234,8 +215,7 @@ internal/
   globals/globals.go           Build-time variables (version)
   logger/logger.go             slog structured logging (TTY detection)
   healthcheck/healthcheck.go   Health check service
-  middleware/middleware.go      HTTP middleware (logging, CORS, security
-                               headers, metrics auth)
+  middleware/middleware.go      HTTP middleware (logging, CORS, metrics auth)
   handlers/handlers.go         HTTP request handlers
   server/
     server.go                  HTTP server lifecycle

TODO.md

@@ -25,16 +25,14 @@ confirm make check still passes.
 
 # Completed Steps
 
-- 2026-08-09: security response headers middleware
-  (`SecurityHeaders()` in `internal/middleware/middleware.go`)
-  registered globally in `internal/server/routes.go`, so HSTS, CSP,
-  `X-Frame-Options`, `X-Content-Type-Options`, `Referrer-Policy`, and
-  `Permissions-Policy` are set on every response including `/s/...` and
-  `/metrics`; the CSP needs no `unsafe-inline`/`unsafe-eval` because the
-  dashboard ships no JavaScript and no inline styles; HSTS is emitted
-  unconditionally per policy (TLS-terminating proxy in front). Remaining
-  1.0 hardening items — `http.Server` timeouts, request body limits,
-  rate limiting, CORS scoping — are tracked separately
+- 2026-08-09: `http.Server` now sets all four socket-level timeouts
+  (`ReadTimeout` 15s, `ReadHeaderTimeout` 10s, `WriteTimeout` 75s,
+  `IdleTimeout` 120s) as named constants in `internal/server/server.go`,
+  closing the slowloris / unreaped-keep-alive exposure required by
+  `REPO_POLICIES.md` before 1.0; `WriteTimeout` is deliberately greater
+  than the 60s `chimw.Timeout` handler budget so that budget stays
+  reachable, and tests in `internal/server` pin both the non-zero
+  values and that relationship (#99)
 - 2026-08-07: golangci-lint bumped to v2.12.2 (commit-pinned installs
   in `Dockerfile` and `script/bootstrap`); `.golangci.yml` set to the
   org-standard v2-schema config used across the org's repos

internal/middleware/middleware.go

@@ -21,60 +21,6 @@ import (
 // corsMaxAge is the maximum age for CORS preflight responses.
 const corsMaxAge = 300
 
-// Security response header values applied to every response.
-//
-// The CSP is as strict as the dashboard allows: the template ships no
-// JavaScript, no inline styles, no inline event handlers and no images,
-// and its only subresource is the embedded stylesheet at
-// /s/css/tailwind.min.css, which style-src 'self' permits. Neither
-// unsafe-inline nor unsafe-eval is used. frame-ancestors 'none' is the
-// primary anti-framing control; X-Frame-Options is the legacy fallback.
-const (
-	// hstsValue is emitted unconditionally, including over plain HTTP,
-	// because the service runs behind a TLS-terminating proxy and the
-	// browser must still enforce HTTPS end to end.
-	hstsValue = "max-age=31536000; includeSubDomains"
-
-	cspValue = "default-src 'self'; " +
-		"script-src 'none'; " +
-		"style-src 'self'; " +
-		"img-src 'self'; " +
-		"font-src 'none'; " +
-		"connect-src 'none'; " +
-		"object-src 'none'; " +
-		"base-uri 'none'; " +
-		"form-action 'none'; " +
-		"frame-ancestors 'none'"
-
-	frameOptionsValue = "DENY"
-
-	contentTypeOptionsValue = "nosniff"
-
-	// referrerPolicyValue is stricter than the policy minimum of
-	// strict-origin-when-cross-origin: the dashboard has no
-	// cross-origin navigation needs and its URL may name internal
-	// hosts.
-	referrerPolicyValue = "no-referrer"
-
-	permissionsPolicyValue = "accelerometer=(), " +
-		"autoplay=(), " +
-		"camera=(), " +
-		"display-capture=(), " +
-		"encrypted-media=(), " +
-		"fullscreen=(), " +
-		"geolocation=(), " +
-		"gyroscope=(), " +
-		"magnetometer=(), " +
-		"microphone=(), " +
-		"midi=(), " +
-		"payment=(), " +
-		"picture-in-picture=(), " +
-		"publickey-credentials-get=(), " +
-		"screen-wake-lock=(), " +
-		"usb=(), " +
-		"xr-spatial-tracking=()"
-)
-
 // Params contains dependencies for Middleware.
 type Params struct {
 	fx.In
@@ -240,37 +186,6 @@ func (m *Middleware) CORS() func(http.Handler) http.Handler {
 	})
 }
 
-// SecurityHeaders returns middleware that sets the security response
-// headers required for production internet exposure on every response.
-//
-// The headers are set before the request reaches the next handler so
-// that they are present on every response, including panics recovered
-// by chi's Recoverer and timeouts produced by chi's Timeout.
-func (m *Middleware) SecurityHeaders() func(http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(
-			writer http.ResponseWriter,
-			request *http.Request,
-		) {
-			header := writer.Header()
-			header.Set("Strict-Transport-Security", hstsValue)
-			header.Set("Content-Security-Policy", cspValue)
-			header.Set("X-Frame-Options", frameOptionsValue)
-			header.Set(
-				"X-Content-Type-Options",
-				contentTypeOptionsValue,
-			)
-			header.Set("Referrer-Policy", referrerPolicyValue)
-			header.Set(
-				"Permissions-Policy",
-				permissionsPolicyValue,
-			)
-
-			next.ServeHTTP(writer, request)
-		})
-	}
-}
-
 // MetricsAuth returns basic auth middleware for /metrics.
 func (m *Middleware) MetricsAuth() func(http.Handler) http.Handler {
 	if m.params.Config.MetricsUsername == "" {

internal/middleware/middleware_test.go

@@ -1,333 +0,0 @@
-package middleware_test
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/go-chi/chi/v5"
-
-	"sneak.berlin/go/dnswatcher/internal/config"
-	"sneak.berlin/go/dnswatcher/internal/globals"
-	"sneak.berlin/go/dnswatcher/internal/handlers"
-	"sneak.berlin/go/dnswatcher/internal/logger"
-	"sneak.berlin/go/dnswatcher/internal/middleware"
-	"sneak.berlin/go/dnswatcher/internal/notify"
-	"sneak.berlin/go/dnswatcher/internal/state"
-)
-
-// Expected security header values, spelled out literally so that any
-// change to the middleware has to be made deliberately here as well.
-const (
-	wantHSTS = "max-age=31536000; includeSubDomains"
-
-	wantCSP = "default-src 'self'; " +
-		"script-src 'none'; " +
-		"style-src 'self'; " +
-		"img-src 'self'; " +
-		"font-src 'none'; " +
-		"connect-src 'none'; " +
-		"object-src 'none'; " +
-		"base-uri 'none'; " +
-		"form-action 'none'; " +
-		"frame-ancestors 'none'"
-
-	wantFrameOptions = "DENY"
-
-	wantContentTypeOptions = "nosniff"
-
-	wantReferrerPolicy = "no-referrer"
-
-	wantPermissionsPolicy = "accelerometer=(), " +
-		"autoplay=(), " +
-		"camera=(), " +
-		"display-capture=(), " +
-		"encrypted-media=(), " +
-		"fullscreen=(), " +
-		"geolocation=(), " +
-		"gyroscope=(), " +
-		"magnetometer=(), " +
-		"microphone=(), " +
-		"midi=(), " +
-		"payment=(), " +
-		"picture-in-picture=(), " +
-		"publickey-credentials-get=(), " +
-		"screen-wake-lock=(), " +
-		"usb=(), " +
-		"xr-spatial-tracking=()"
-)
-
-// stylesheetPath is the only subresource the dashboard loads.
-const stylesheetPath = "/s/css/tailwind.min.css"
-
-// newTestLogger builds a logger for direct component construction.
-func newTestLogger(t *testing.T) *logger.Logger {
-	t.Helper()
-
-	glob, err := globals.New(nil)
-	if err != nil {
-		t.Fatalf("globals.New: %v", err)
-	}
-
-	log, err := logger.New(nil, logger.Params{Globals: glob})
-	if err != nil {
-		t.Fatalf("logger.New: %v", err)
-	}
-
-	return log
-}
-
-// newTestMiddleware builds a Middleware without an fx application.
-func newTestMiddleware(t *testing.T) *middleware.Middleware {
-	t.Helper()
-
-	glob, err := globals.New(nil)
-	if err != nil {
-		t.Fatalf("globals.New: %v", err)
-	}
-
-	mw, err := middleware.New(nil, middleware.Params{
-		Logger:  newTestLogger(t),
-		Globals: glob,
-		Config:  &config.Config{},
-	})
-	if err != nil {
-		t.Fatalf("middleware.New: %v", err)
-	}
-
-	return mw
-}
-
-// serveWithSecurityHeaders runs a GET through SecurityHeaders and
-// returns the recorded response.
-func serveWithSecurityHeaders(
-	t *testing.T,
-	target string,
-	handler http.Handler,
-) *httptest.ResponseRecorder {
-	t.Helper()
-
-	mw := newTestMiddleware(t)
-	rec := httptest.NewRecorder()
-	req := httptest.NewRequestWithContext(
-		t.Context(), http.MethodGet, target, nil,
-	)
-
-	mw.SecurityHeaders()(handler).ServeHTTP(rec, req)
-
-	return rec
-}
-
-// okHandler writes a trivial 200 response.
-func okHandler() http.Handler {
-	return http.HandlerFunc(func(
-		writer http.ResponseWriter,
-		_ *http.Request,
-	) {
-		writer.WriteHeader(http.StatusOK)
-	})
-}
-
-func TestSecurityHeaders(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name   string
-		header string
-		want   string
-	}{
-		{
-			"hsts",
-			"Strict-Transport-Security",
-			wantHSTS,
-		},
-		{
-			"csp",
-			"Content-Security-Policy",
-			wantCSP,
-		},
-		{
-			"frame options",
-			"X-Frame-Options",
-			wantFrameOptions,
-		},
-		{
-			"content type options",
-			"X-Content-Type-Options",
-			wantContentTypeOptions,
-		},
-		{
-			"referrer policy",
-			"Referrer-Policy",
-			wantReferrerPolicy,
-		},
-		{
-			"permissions policy",
-			"Permissions-Policy",
-			wantPermissionsPolicy,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			rec := serveWithSecurityHeaders(t, "/", okHandler())
-
-			got := rec.Header().Get(tt.header)
-			if got != tt.want {
-				t.Errorf(
-					"%s = %q, want %q",
-					tt.header, got, tt.want,
-				)
-			}
-		})
-	}
-}
-
-// TestSecurityHeadersCSPDirectives guards the properties the repo
-// policy requires of the content security policy itself.
-func TestSecurityHeadersCSPDirectives(t *testing.T) {
-	t.Parallel()
-
-	rec := serveWithSecurityHeaders(t, "/", okHandler())
-	csp := rec.Header().Get("Content-Security-Policy")
-
-	forbidden := []string{"unsafe-inline", "unsafe-eval"}
-	for _, directive := range forbidden {
-		if strings.Contains(csp, directive) {
-			t.Errorf("CSP must not contain %q: %q", directive, csp)
-		}
-	}
-
-	required := []string{
-		"default-src 'self'",
-		"script-src 'none'",
-		"style-src 'self'",
-		"frame-ancestors 'none'",
-	}
-	for _, directive := range required {
-		if !strings.Contains(csp, directive) {
-			t.Errorf("CSP must contain %q: %q", directive, csp)
-		}
-	}
-}
-
-// TestSecurityHeadersOnErrorResponse verifies the headers are emitted
-// even when the wrapped handler fails, since they are set before the
-// handler runs.
-func TestSecurityHeadersOnErrorResponse(t *testing.T) {
-	t.Parallel()
-
-	failing := http.HandlerFunc(func(
-		writer http.ResponseWriter,
-		_ *http.Request,
-	) {
-		http.Error(
-			writer,
-			"boom",
-			http.StatusInternalServerError,
-		)
-	})
-
-	rec := serveWithSecurityHeaders(t, "/api/v1/status", failing)
-
-	if rec.Code != http.StatusInternalServerError {
-		t.Fatalf("status = %d, want 500", rec.Code)
-	}
-
-	if got := rec.Header().Get(
-		"X-Content-Type-Options",
-	); got != wantContentTypeOptions {
-		t.Errorf(
-			"X-Content-Type-Options = %q, want %q",
-			got, wantContentTypeOptions,
-		)
-	}
-
-	if got := rec.Header().Get(
-		"Strict-Transport-Security",
-	); got != wantHSTS {
-		t.Errorf(
-			"Strict-Transport-Security = %q, want %q",
-			got, wantHSTS,
-		)
-	}
-}
-
-// newTestHandlers builds real Handlers with empty monitoring state.
-func newTestHandlers(t *testing.T) *handlers.Handlers {
-	t.Helper()
-
-	glob, err := globals.New(nil)
-	if err != nil {
-		t.Fatalf("globals.New: %v", err)
-	}
-
-	log := newTestLogger(t)
-
-	notifier, err := notify.New(nil, notify.Params{
-		Logger: log,
-		Config: &config.Config{},
-	})
-	if err != nil {
-		t.Fatalf("notify.New: %v", err)
-	}
-
-	hnd, err := handlers.New(nil, handlers.Params{
-		Logger:  log,
-		Globals: glob,
-		State:   state.NewForTest(),
-		Notify:  notifier,
-	})
-	if err != nil {
-		t.Fatalf("handlers.New: %v", err)
-	}
-
-	return hnd
-}
-
-// TestDashboardRendersWithSecurityHeaders renders the real dashboard
-// through the middleware and checks that the policy still permits the
-// one stylesheet the page loads.
-func TestDashboardRendersWithSecurityHeaders(t *testing.T) {
-	t.Parallel()
-
-	mw := newTestMiddleware(t)
-	hnd := newTestHandlers(t)
-
-	router := chi.NewRouter()
-	router.Use(mw.SecurityHeaders())
-	router.Get("/", hnd.HandleDashboard())
-
-	rec := httptest.NewRecorder()
-	req := httptest.NewRequestWithContext(
-		t.Context(), http.MethodGet, "/", nil,
-	)
-
-	router.ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("status = %d, want 200", rec.Code)
-	}
-
-	body := rec.Body.String()
-	if !strings.Contains(body, stylesheetPath) {
-		t.Errorf("dashboard does not reference %q", stylesheetPath)
-	}
-
-	if !strings.Contains(body, "dnswatcher") {
-		t.Errorf("dashboard body looks empty: %d bytes", len(body))
-	}
-
-	csp := rec.Header().Get("Content-Security-Policy")
-	if csp != wantCSP {
-		t.Errorf("CSP = %q, want %q", csp, wantCSP)
-	}
-
-	// The stylesheet is same-origin, so style-src 'self' allows it.
-	if !strings.Contains(csp, "style-src 'self'") {
-		t.Errorf("CSP would block %q: %q", stylesheetPath, csp)
-	}
-}

internal/server/export_test.go

@@ -0,0 +1,19 @@
+package server
+
+import (
+	"net/http"
+	"time"
+)
+
+// NewHTTPServer exports newHTTPServer for testing.
+func NewHTTPServer(
+	listenAddr string,
+	handler http.Handler,
+) *http.Server {
+	return newHTTPServer(listenAddr, handler)
+}
+
+// RequestTimeout exports the handler execution budget applied by
+// chimw.Timeout in SetupRoutes, so tests can assert the relationship
+// between it and the server's WriteTimeout.
+const RequestTimeout time.Duration = requestTimeout

internal/server/routes.go

@@ -21,7 +21,6 @@ func (s *Server) SetupRoutes() {
 	// Global middleware
 	s.router.Use(chimw.Recoverer)
 	s.router.Use(chimw.RequestID)
-	s.router.Use(s.mw.SecurityHeaders())
 	s.router.Use(s.mw.Logging())
 	s.router.Use(s.mw.CORS())
 	s.router.Use(chimw.Timeout(requestTimeout))

internal/server/server.go

@@ -33,8 +33,52 @@ type Params struct {
 // shutdownTimeout is how long to wait for graceful shutdown.
 const shutdownTimeout = 30 * time.Second
 
-// readHeaderTimeout is the max duration for reading request headers.
-const readHeaderTimeout = 10 * time.Second
+// Socket-level timeouts for the HTTP server.
+//
+// These bound time spent on the connection itself and are a distinct
+// control from the per-request handler budget enforced by
+// chimw.Timeout(requestTimeout) in routes.go: that one cancels the
+// request context after requestTimeout but never touches the socket,
+// so without the values below a peer can hold a connection open
+// forever (slowloris, unreaped keep-alives).
+//
+// The one hard constraint between the two controls is
+// writeTimeout > requestTimeout. net/http arms the write deadline
+// once the request headers have been read, so on a plaintext
+// connection it covers handler execution AND the response flush. If
+// writeTimeout were <= requestTimeout the server would sever the
+// connection before a handler that legitimately consumed its full
+// budget could emit anything, making the 60s budget unreachable in
+// practice. The margin between them is the response-flush allowance.
+//
+// The only clients of this service are browsers loading the dashboard
+// and a Prometheus scraper; the values are sized for those.
+const (
+	// readHeaderTimeout is the max duration for reading request
+	// headers.
+	readHeaderTimeout = 10 * time.Second
+
+	// readTimeout bounds reading the entire request, headers plus
+	// body. Every route here is a GET with no body, so this only
+	// ever needs to cover headers; the extra 5s over
+	// readHeaderTimeout is slack, not a real allowance, and keeps a
+	// body dribbled one byte at a time from holding the read side
+	// open indefinitely.
+	readTimeout = 15 * time.Second
+
+	// writeTimeout must exceed the requestTimeout handler budget
+	// (60s) per the note above. The 15s difference is the allowance
+	// for flushing a completed response to a slow client.
+	writeTimeout = 75 * time.Second
+
+	// idleTimeout reaps keep-alive connections between requests. It
+	// is deliberately longer than the common Prometheus scrape
+	// intervals (15s/30s/60s) so the scraper reuses its connection
+	// rather than reconnecting every cycle, while a browser tab
+	// left open on the dashboard stops occupying a connection
+	// within two minutes of going quiet.
+	idleTimeout = 120 * time.Second
+)
 
 // Server is the HTTP server.
 type Server struct {
@@ -76,16 +120,29 @@ func New(
 	return srv, nil
 }
 
+// newHTTPServer builds the listening http.Server with every
+// socket-level timeout set. All four are set deliberately: a zero
+// value in net/http means "no limit", not "some default".
+func newHTTPServer(
+	listenAddr string,
+	handler http.Handler,
+) *http.Server {
+	return &http.Server{
+		Addr:              listenAddr,
+		Handler:           handler,
+		ReadTimeout:       readTimeout,
+		ReadHeaderTimeout: readHeaderTimeout,
+		WriteTimeout:      writeTimeout,
+		IdleTimeout:       idleTimeout,
+	}
+}
+
 // Run starts the HTTP server.
 func (s *Server) Run() {
 	s.SetupRoutes()
 
 	listenAddr := fmt.Sprintf(":%d", s.port)
-	s.httpServer = &http.Server{
-		Addr:              listenAddr,
-		Handler:           s,
-		ReadHeaderTimeout: readHeaderTimeout,
-	}
+	s.httpServer = newHTTPServer(listenAddr, s)
 
 	s.log.Info("http server starting", "addr", listenAddr)
 

internal/server/server_test.go

@@ -0,0 +1,112 @@
+package server_test
+
+import (
+	"net/http"
+	"testing"
+
+	"sneak.berlin/go/dnswatcher/internal/server"
+)
+
+// noopHandler stands in for the router; newHTTPServer only stores it.
+func noopHandler() http.Handler {
+	return http.HandlerFunc(
+		func(w http.ResponseWriter, _ *http.Request) {
+			w.WriteHeader(http.StatusOK)
+		},
+	)
+}
+
+// TestHTTPServerTimeoutsAreSet asserts that every socket-level
+// timeout is configured. A zero value in net/http means "no limit",
+// so a refactor that silently drops one of these reintroduces the
+// slowloris / unreaped-keep-alive exposure this guards against.
+//
+// The assertions are on the configured field values only; nothing
+// here measures elapsed time, so the test cannot flake on timing.
+func TestHTTPServerTimeoutsAreSet(t *testing.T) {
+	t.Parallel()
+
+	srv := server.NewHTTPServer(":8080", noopHandler())
+
+	if srv.ReadTimeout <= 0 {
+		t.Errorf(
+			"ReadTimeout must be non-zero, got %v",
+			srv.ReadTimeout,
+		)
+	}
+
+	if srv.ReadHeaderTimeout <= 0 {
+		t.Errorf(
+			"ReadHeaderTimeout must be non-zero, got %v",
+			srv.ReadHeaderTimeout,
+		)
+	}
+
+	if srv.WriteTimeout <= 0 {
+		t.Errorf(
+			"WriteTimeout must be non-zero, got %v",
+			srv.WriteTimeout,
+		)
+	}
+
+	if srv.IdleTimeout <= 0 {
+		t.Errorf(
+			"IdleTimeout must be non-zero, got %v",
+			srv.IdleTimeout,
+		)
+	}
+}
+
+// TestWriteTimeoutExceedsHandlerBudget pins the one relationship the
+// values must satisfy. net/http arms the write deadline once request
+// headers are read, so it covers handler execution plus the response
+// flush. If WriteTimeout were not greater than the chimw.Timeout
+// handler budget, the connection would be severed before a handler
+// that used its full budget could respond, making that budget
+// unreachable.
+func TestWriteTimeoutExceedsHandlerBudget(t *testing.T) {
+	t.Parallel()
+
+	srv := server.NewHTTPServer(":8080", noopHandler())
+
+	if srv.WriteTimeout <= server.RequestTimeout {
+		t.Errorf(
+			"WriteTimeout (%v) must exceed handler budget (%v)",
+			srv.WriteTimeout,
+			server.RequestTimeout,
+		)
+	}
+}
+
+// TestReadTimeoutCoversHeaderTimeout asserts the read deadline for
+// the whole request is at least as long as the header-only deadline;
+// a smaller ReadTimeout would make ReadHeaderTimeout unreachable.
+func TestReadTimeoutCoversHeaderTimeout(t *testing.T) {
+	t.Parallel()
+
+	srv := server.NewHTTPServer(":8080", noopHandler())
+
+	if srv.ReadTimeout < srv.ReadHeaderTimeout {
+		t.Errorf(
+			"ReadTimeout (%v) must be >= ReadHeaderTimeout (%v)",
+			srv.ReadTimeout,
+			srv.ReadHeaderTimeout,
+		)
+	}
+}
+
+// TestHTTPServerAddrAndHandler covers the rest of the constructor so
+// a future edit cannot drop the listen address or the handler.
+func TestHTTPServerAddrAndHandler(t *testing.T) {
+	t.Parallel()
+
+	srv := server.NewHTTPServer(":9999", noopHandler())
+
+	if srv.Addr != ":9999" {
+		t.Errorf("Addr = %q, want %q", srv.Addr, ":9999")
+	}
+
+	if srv.Handler == nil {
+		t.Error("Handler must not be nil")
+	}
+}