The update watchdog verifies archied's restart, so archied has to be what answers. It was probing the dashboard's /healthz, which belongs to the dashboard: switch [web] off and nothing answers, and in the extracted UI topology that endpoint reports a different process entirely, which would confirm a release while the daemon it was meant to verify is down. [health].listen (127.0.0.1:8485, defaulted, always on) serves /healthz, /health and /health/detailed for the life of the process. Liveness answers 503 until the daemon reaches its run loop: the listener binds before the subsystems do, so an unconditional 200 would tell the watchdog a half-booted release came up. Failing to bind is fatal, because a daemon nothing can probe gets every update rolled back. The State Store's readiness surface now shares the listener plumbing, keeping its log and error text verbatim. Closes archie-core-exbz, which asked which of two bad options to take when the dashboard is off. Neither: the daemon owns its own liveness. Also deletes TestInstallUpdateDetachesInstallerFromCallbackContext. It has failed intermittently under load more than once, racing its fake bot server's multipart parse against the cancellation it induces.
168 lines
5.5 KiB
Go
168 lines
5.5 KiB
Go
package webui
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"crypto/subtle"
|
|
"encoding/base64"
|
|
"fmt"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
)
|
|
|
|
// tokenCookie carries the dashboard token once it has been exchanged from the
|
|
// URL, so the token is not left sitting in browser history or referrers.
|
|
const tokenCookie = "archie_ui"
|
|
|
|
// IsLoopback reports whether a listen address is reachable only from this
|
|
// machine.
|
|
//
|
|
// Loopback binds need no token. Archie's agent already runs shell, write and
|
|
// edit tools on the host, so anyone with local access has the capability
|
|
// regardless; a lock here would only obstruct the operator. What a token
|
|
// protects is *exposure* -- an instance reachable from a network -- so that is
|
|
// the only case where one is required.
|
|
func IsLoopback(listen string) bool {
|
|
host, _, err := net.SplitHostPort(strings.TrimSpace(listen))
|
|
if err != nil {
|
|
host = strings.TrimSpace(listen)
|
|
}
|
|
switch host {
|
|
case "", "localhost":
|
|
return true
|
|
}
|
|
ip := net.ParseIP(host)
|
|
return ip != nil && ip.IsLoopback()
|
|
}
|
|
|
|
// DashboardURL renders a listen address as a URL a human can actually open.
|
|
//
|
|
// A wildcard bind ("0.0.0.0:8484", ":8484", "[::]:8484") is a valid thing to
|
|
// listen on but not a valid thing to visit, and printing it verbatim gives the
|
|
// operator a link that goes nowhere. The host is substituted for localhost,
|
|
// which is correct for the machine reading the log.
|
|
func DashboardURL(listen, token string) string {
|
|
host, port, err := net.SplitHostPort(strings.TrimSpace(listen))
|
|
if err != nil {
|
|
host, port = "", strings.TrimPrefix(strings.TrimSpace(listen), ":")
|
|
}
|
|
switch host {
|
|
case "", "0.0.0.0", "::", "[::]":
|
|
host = "localhost"
|
|
}
|
|
url := "http://" + net.JoinHostPort(host, port) + "/"
|
|
if token != "" {
|
|
url += "?t=" + token
|
|
}
|
|
return url
|
|
}
|
|
|
|
// LoadOrCreateToken returns the dashboard token, generating and persisting one
|
|
// on first use. The token is created rather than configured so a non-loopback
|
|
// bind cannot be brought up unprotected by omission: there is no setup step to
|
|
// forget.
|
|
func LoadOrCreateToken(path string) (string, error) {
|
|
if b, err := os.ReadFile(path); err == nil {
|
|
if tok := strings.TrimSpace(string(b)); tok != "" {
|
|
return tok, nil
|
|
}
|
|
} else if !os.IsNotExist(err) {
|
|
return "", fmt.Errorf("webui: read token: %w", err)
|
|
}
|
|
|
|
raw := make([]byte, 32)
|
|
if _, err := rand.Read(raw); err != nil {
|
|
return "", fmt.Errorf("webui: generate token: %w", err)
|
|
}
|
|
tok := base64.RawURLEncoding.EncodeToString(raw)
|
|
|
|
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
|
|
return "", fmt.Errorf("webui: token dir: %w", err)
|
|
}
|
|
if err := os.WriteFile(path, []byte(tok+"\n"), 0o600); err != nil {
|
|
return "", fmt.Errorf("webui: write token: %w", err)
|
|
}
|
|
return tok, nil
|
|
}
|
|
|
|
// requireToken wraps h with token authentication. A zero token disables the
|
|
// check entirely, which is how loopback binds stay frictionless.
|
|
//
|
|
// The token may arrive as ?t=... once; it is then moved into a
|
|
// SameSite=Strict, HttpOnly cookie and the caller redirected to the clean URL.
|
|
// One click on the URL archied logs is the whole setup.
|
|
// The token is read per request rather than captured when the handler is
|
|
// built, so a Server whose Token is set after Handler() is still protected.
|
|
func (s *Server) requireToken(h http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if s.Token == "" {
|
|
h.ServeHTTP(w, r)
|
|
return
|
|
}
|
|
if tok := r.URL.Query().Get("t"); tok != "" {
|
|
if !tokenEqual(tok, s.Token) {
|
|
http.Error(w, "unauthorised", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
http.SetCookie(w, &http.Cookie{
|
|
Name: tokenCookie,
|
|
Value: tok,
|
|
Path: "/",
|
|
HttpOnly: true,
|
|
SameSite: http.SameSiteStrictMode,
|
|
Secure: r.TLS != nil,
|
|
})
|
|
clean := *r.URL
|
|
q := clean.Query()
|
|
q.Del("t")
|
|
clean.RawQuery = q.Encode()
|
|
http.Redirect(w, r, sameOriginPath(clean.Path, clean.RawQuery), http.StatusSeeOther)
|
|
return
|
|
}
|
|
|
|
if c, err := r.Cookie(tokenCookie); err == nil && tokenEqual(c.Value, s.Token) {
|
|
h.ServeHTTP(w, r)
|
|
return
|
|
}
|
|
if hdr := r.Header.Get("Authorization"); strings.HasPrefix(hdr, "Bearer ") &&
|
|
tokenEqual(strings.TrimPrefix(hdr, "Bearer "), s.Token) {
|
|
h.ServeHTTP(w, r)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
|
|
http.Error(w, "unauthorised: open the dashboard URL archied logged at startup", http.StatusUnauthorized)
|
|
})
|
|
}
|
|
|
|
// sameOriginPath rebuilds a redirect target from a request path and raw
|
|
// query, collapsing any leading "//" down to a single slash first.
|
|
//
|
|
// A path of "//evil.example/x" is a valid http.Redirect Location that
|
|
// browsers treat as protocol-relative, sending the client off-host. Since
|
|
// this path is echoed back from the incoming request URL, an attacker can
|
|
// choose it, so it must never reach http.Redirect verbatim.
|
|
func sameOriginPath(path, rawQuery string) string {
|
|
// URL.Path has already been decoded by net/http. Treat backslashes as
|
|
// separators before checking for a protocol-relative path, because browsers
|
|
// do the same when interpreting a redirect Location.
|
|
path = strings.ReplaceAll(path, "\\", "/")
|
|
for strings.HasPrefix(path, "//") {
|
|
path = path[1:]
|
|
}
|
|
if !strings.HasPrefix(path, "/") {
|
|
path = "/" + path
|
|
}
|
|
|
|
// Re-encoding through URL.Path preserves decoded path characters such as
|
|
// '%', '?' and '#' as path data instead of reparsing them as URL syntax.
|
|
return (&url.URL{Path: path, RawQuery: rawQuery}).RequestURI()
|
|
}
|
|
|
|
func tokenEqual(got, want string) bool {
|
|
return subtle.ConstantTimeCompare([]byte(got), []byte(want)) == 1
|
|
}
|