Files
pipelines/internal/server/request_boundary.go
T
alan 1ad85de1f1 Keep step-up elevation for the signed-in session and stop gating terminals
The proxy forwards an HMAC-derived session id (X-Pipelines-Session) on
/connect and POST /files; the server trusts it only on token-authenticated
requests and keys elevation by it, so reconnects stay elevated up to a 24 h
cap. Terminals rely on their su -l login. The app no longer forgets the
elevation on disconnect and asks again only on a fresh refusal.
2026-11-10 03:00:45 +00:00

119 lines
4.2 KiB
Go

package server
import (
"context"
"net"
"net/http"
"strings"
"git.a-wan.net/alan/pipelines/internal/protocol"
"git.a-wan.net/alan/pipelines/internal/servertoken"
)
// requestBoundary is the server's HTTP front door, applied before any route
// (docs/notes/security-boundary.md):
//
// - Host: a connection that arrived on a loopback address must name a
// loopback literal (127.0.0.1, localhost, [::1]) with the port it reached,
// so a DNS-rebinding page (Host: rebind.example:8080) is refused with 421.
// A connection that arrived on another interface exists only when the
// server was explicitly bound beyond loopback; its Host is not checked.
// - Origin: /connect refuses any request carrying Origin. Browsers always
// send it on a WebSocket upgrade; the web proxy strips it and the CLI, the
// TUI and the native app send none.
// - Token: when the server is configured with the shared secret, every
// request must carry it in servertoken.Header, except the chat-tools MCP
// endpoint (its own per-chat token, loopback and no-Origin checks) and
// /healthz (a bare liveness boolean).
// - Session: protocol.SessionHeader names the web session a proxied request
// belongs to (an opaque id the proxy derives from the verified cookie). It
// is trusted only on a request that carried the configured token; it is
// always removed from the request and, when trusted, reaches handlers
// through the context (trustedSession).
type requestBoundary struct {
next http.Handler
token string
}
func guardRequests(next http.Handler, token string) http.Handler {
return requestBoundary{next: next, token: token}
}
func (b requestBoundary) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if !allowedHost(r) {
http.Error(w, "misdirected request: this server answers only its own loopback address", http.StatusMisdirectedRequest)
return
}
if r.URL.Path == "/connect" && r.Header.Get("Origin") != "" {
http.Error(w, "browser origins may not connect directly; use the web proxy", http.StatusForbidden)
return
}
if b.token != "" && !tokenExempt(r.URL.Path) && !servertoken.Equal(r.Header.Get(servertoken.Header), b.token) {
http.Error(w, "server token required", http.StatusUnauthorized)
return
}
// The secret never reaches a handler, a log line or a forwarded request.
r.Header.Del(servertoken.Header)
session := r.Header.Get(protocol.SessionHeader)
r.Header.Del(protocol.SessionHeader)
if b.token != "" && validSessionID(session) {
r = r.WithContext(context.WithValue(r.Context(), sessionContextKey{}, session))
}
b.next.ServeHTTP(w, r)
}
type sessionContextKey struct{}
// trustedSession is the web session id the token-authenticated proxy reported
// for r, or "" (no server token configured, a direct client, or no header).
func trustedSession(r *http.Request) string {
session, _ := r.Context().Value(sessionContextKey{}).(string)
return session
}
// validSessionID bounds the proxy's opaque id: 16 to 128 URL-safe characters.
func validSessionID(value string) bool {
if len(value) < 16 || len(value) > 128 {
return false
}
for _, c := range value {
if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c == '-' || c == '_') {
return false
}
}
return true
}
func tokenExempt(path string) bool {
return path == "/healthz" || strings.HasPrefix(path, chatToolPath)
}
// allowedHost applies the loopback Host rule. A request with no recorded local
// address (an in-process test handler) has no listener to compare against.
func allowedHost(r *http.Request) bool {
local, ok := r.Context().Value(http.LocalAddrContextKey).(net.Addr)
if !ok || local == nil {
return true
}
localHost, localPort, err := net.SplitHostPort(local.String())
if err != nil {
return false
}
if ip := net.ParseIP(localHost); ip == nil || !ip.IsLoopback() {
return true
}
host, port, err := net.SplitHostPort(r.Host)
if err != nil {
// No port: only the default HTTP port could match.
host, port = strings.TrimSuffix(strings.TrimPrefix(r.Host, "["), "]"), "80"
}
if port != localPort {
return false
}
if strings.EqualFold(host, "localhost") {
return true
}
ip := net.ParseIP(host)
return ip != nil && ip.IsLoopback() && !strings.Contains(host, "%")
}