Security fixes for v27.1-rc.15 #76
No files matched your search
@@ -3,14 +3,16 @@
|
||||
#
|
||||
# Weekly check that the releases this installer pins (internal/release) have
|
||||
# not fallen behind the newest release of inbuxa-server, inbuxa-admin and
|
||||
# inbuxa-webmail. A fresh install ships whatever release.go names, so a pin
|
||||
# left behind is a fresh install shipped stale -- and, if the skipped release
|
||||
# fixed a vulnerability, shipped vulnerable.
|
||||
# inbuxa-webmail, nor Caddy behind Docker Hub's newest patch of its series or
|
||||
# a rebuild of its own version. A fresh install ships whatever release.go
|
||||
# names, so a pin left behind is a fresh install shipped stale -- and, if the
|
||||
# skipped release fixed a vulnerability, shipped vulnerable.
|
||||
#
|
||||
# A stale pin fails this run (exit 10) and opens or updates a tracking issue;
|
||||
# the fix is a reviewed change to release.go with the new checksums, never an
|
||||
# automatic edit. The release reads are public, so they need no token; --issue
|
||||
# uses the run token to write the issue in this repository.
|
||||
# the fix is a reviewed change to release.go with the new checksums (and
|
||||
# Caddy's new digest), never an automatic edit. The release reads are public,
|
||||
# so they need no token; --issue uses the run token to write the issue in
|
||||
# this repository.
|
||||
name: pin-check
|
||||
|
||||
on:
|
||||
|
||||
+74
-12
@@ -10,13 +10,19 @@
|
||||
// on an error -- so a scheduled job turns a stale pin into a red run (and, with
|
||||
// --issue, an open issue) instead of a fresh install shipped stale.
|
||||
//
|
||||
// Caddy, pinned by the digest of its image on Docker Hub, is read from Docker
|
||||
// Hub's tags instead: it is behind when a newer X.Y.Z-alpine of its series is
|
||||
// there, or when its own version's tag now names another image (Docker Hub
|
||||
// rebuilds an image for a new Alpine under the same tag).
|
||||
//
|
||||
// It only reads; it never edits release.go. The move itself stays a reviewed
|
||||
// change: the report names the version to move to, and release.go's checksums
|
||||
// are still taken from each release's signed SHA256SUMS by hand.
|
||||
// are still taken from each release's signed SHA256SUMS by hand, and Caddy's
|
||||
// digest from its image index.
|
||||
//
|
||||
// Usage:
|
||||
//
|
||||
// pin-check [--base-url URL] [--timeout D] [--issue]
|
||||
// pin-check [--base-url URL] [--hub-url URL] [--timeout D] [--issue]
|
||||
//
|
||||
// GITEA_TOKEN, if set, authenticates the API reads (needed while the
|
||||
// repositories are private). --issue opens or updates a tracking issue in this
|
||||
@@ -55,6 +61,7 @@ func components() []component {
|
||||
|
||||
func main() {
|
||||
baseURL := flag.String("base-url", "https://git.coffeylabs.org", "the Gitea base URL whose releases to read")
|
||||
hubURL := flag.String("hub-url", "https://hub.docker.com", "the Docker Hub base URL whose caddy tags to read")
|
||||
timeout := flag.Duration("timeout", 30*time.Second, "overall deadline for the API reads")
|
||||
openIssue := flag.Bool("issue", false, "open or update a tracking issue in this repo when a pin is stale")
|
||||
flag.Parse()
|
||||
@@ -63,7 +70,7 @@ func main() {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), *timeout)
|
||||
defer cancel()
|
||||
|
||||
code, err := run(ctx, http.DefaultClient, *baseURL, token, *openIssue)
|
||||
code, err := run(ctx, http.DefaultClient, *baseURL, *hubURL, token, *openIssue)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "pin-check: %v\n", err)
|
||||
os.Exit(1)
|
||||
@@ -71,8 +78,16 @@ func main() {
|
||||
os.Exit(code)
|
||||
}
|
||||
|
||||
func run(ctx context.Context, client *http.Client, baseURL, token string, openIssue bool) (int, error) {
|
||||
func run(ctx context.Context, client *http.Client, baseURL, hubURL, token string, openIssue bool) (int, error) {
|
||||
var findings []pins.Finding
|
||||
report := func(f pins.Finding, stale bool, name, current string) {
|
||||
if stale {
|
||||
findings = append(findings, f)
|
||||
fmt.Printf("STALE %-24s %s -> %s\n", name, f.Current, f.Latest)
|
||||
} else {
|
||||
fmt.Printf("ok %-24s %s\n", name, current)
|
||||
}
|
||||
}
|
||||
for _, c := range components() {
|
||||
rels, err := fetchReleases(ctx, client, baseURL, token, c.repo)
|
||||
if err != nil {
|
||||
@@ -82,13 +97,13 @@ func run(ctx context.Context, client *http.Client, baseURL, token string, openIs
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if stale {
|
||||
findings = append(findings, f)
|
||||
fmt.Printf("STALE %-24s %s -> %s\n", c.Name, f.Current, f.Latest)
|
||||
} else {
|
||||
fmt.Printf("ok %-24s %s\n", c.Name, c.Current)
|
||||
}
|
||||
report(f, stale, c.Name, c.Current)
|
||||
}
|
||||
f, stale, err := checkCaddy(ctx, client, hubURL)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("caddy: %w", err)
|
||||
}
|
||||
report(f, stale, caddyName, release.CaddyVersion)
|
||||
|
||||
if len(findings) == 0 {
|
||||
fmt.Println("\nAll pins are current.")
|
||||
@@ -96,7 +111,8 @@ func run(ctx context.Context, client *http.Client, baseURL, token string, openIs
|
||||
}
|
||||
|
||||
fmt.Printf("\n%d pin(s) behind. Move release.go to the versions above, taking each\n", len(findings))
|
||||
fmt.Println("checksum from that release's signed SHA256SUMS, and open a pull request.")
|
||||
fmt.Println("checksum from that release's signed SHA256SUMS (Caddy's digest from its image index),")
|
||||
fmt.Println("and open a pull request.")
|
||||
if openIssue {
|
||||
if token == "" {
|
||||
return 0, fmt.Errorf("--issue needs GITEA_TOKEN")
|
||||
@@ -185,7 +201,7 @@ func issueBody(findings []pins.Finding) string {
|
||||
for _, f := range findings {
|
||||
fmt.Fprintf(&b, "- **%s**: `%s` -> `%s`\n", f.Component, f.Current, f.Latest)
|
||||
}
|
||||
b.WriteString("\nMove each pin, taking its checksum from that release's signed `SHA256SUMS`, and open a pull request. This issue is maintained by `pin-check`; it updates itself and can be closed once the pins are current.\n")
|
||||
b.WriteString("\nMove each pin, taking its checksum from that release's signed `SHA256SUMS` (Caddy's digest from its image index: `docker buildx imagetools inspect docker.io/library/caddy:<version>-alpine`), and open a pull request. This issue is maintained by `pin-check`; it updates itself and can be closed once the pins are current.\n")
|
||||
return b.String()
|
||||
}
|
||||
|
||||
@@ -241,3 +257,49 @@ func apiWrite(ctx context.Context, client *http.Client, method, u, token string,
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
const caddyName = "caddy (Docker Hub)"
|
||||
|
||||
// hubTag is the slice of a Docker Hub tag the check needs.
|
||||
type hubTag struct {
|
||||
Name string `json:"name"`
|
||||
Digest string `json:"digest"`
|
||||
}
|
||||
|
||||
// checkCaddy compares the Caddy pin with Docker Hub's caddy tags: a newer
|
||||
// X.Y.Z-alpine in the pin's series is a move, and so is the pin's own tag
|
||||
// naming an image other than the pinned digest, which is a rebuild.
|
||||
func checkCaddy(ctx context.Context, client *http.Client, hubURL string) (pins.Finding, bool, error) {
|
||||
u := strings.TrimRight(hubURL, "/") + "/v2/repositories/library/caddy/tags?page_size=100&name=-alpine"
|
||||
body, err := apiGet(ctx, client, u, "")
|
||||
if err != nil {
|
||||
return pins.Finding{}, false, err
|
||||
}
|
||||
var page struct {
|
||||
Results []hubTag `json:"results"`
|
||||
}
|
||||
if err := json.Unmarshal(body, &page); err != nil {
|
||||
return pins.Finding{}, false, fmt.Errorf("decoding tags: %w", err)
|
||||
}
|
||||
var rels []pins.Release
|
||||
rebuilt := ""
|
||||
for _, t := range page.Results {
|
||||
v, ok := strings.CutSuffix(t.Name, "-alpine")
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
rels = append(rels, pins.Release{Tag: v})
|
||||
if v == release.CaddyVersion && t.Digest != "" && t.Digest != release.CaddyDigest {
|
||||
rebuilt = t.Digest
|
||||
}
|
||||
}
|
||||
f, stale, err := pins.Check(pins.Component{Name: caddyName, Current: release.CaddyVersion}, rels)
|
||||
if err != nil || stale {
|
||||
return f, stale, err
|
||||
}
|
||||
if rebuilt != "" {
|
||||
return pins.Finding{Component: caddyName, Current: release.CaddyVersion,
|
||||
Latest: release.CaddyVersion + " rebuilt, now " + rebuilt}, true, nil
|
||||
}
|
||||
return pins.Finding{}, false, nil
|
||||
}
|
||||
@@ -12,6 +12,7 @@ import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/pins"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/release"
|
||||
)
|
||||
|
||||
@@ -50,9 +51,32 @@ func releasesServer(t *testing.T, bump bool) *httptest.Server {
|
||||
_ = json.NewEncoder(w).Encode(rels)
|
||||
})
|
||||
}
|
||||
mux.HandleFunc("/v2/repositories/library/caddy/tags", func(w http.ResponseWriter, r *http.Request) {
|
||||
_ = json.NewEncoder(w).Encode(caddyTags(bump, release.CaddyDigest))
|
||||
})
|
||||
return httptest.NewServer(mux)
|
||||
}
|
||||
|
||||
// caddyTags is a page of Docker Hub's caddy tags: the pinned version's at
|
||||
// digest, a newer patch when bump is true, and the moving and builder tags,
|
||||
// which are not versions to move to.
|
||||
func caddyTags(bump bool, digest string) map[string][]hubTag {
|
||||
tags := []hubTag{
|
||||
{Name: "alpine", Digest: "sha256:moving"},
|
||||
{Name: "2-alpine", Digest: "sha256:moving"},
|
||||
{Name: "2.11-alpine", Digest: "sha256:moving"},
|
||||
{Name: release.CaddyVersion + "-alpine", Digest: digest},
|
||||
{Name: "9.9.9-builder-alpine", Digest: "sha256:builder"},
|
||||
{Name: "2.99.0-beta.1-alpine", Digest: "sha256:beta"},
|
||||
}
|
||||
if bump {
|
||||
v, _ := pins.Parse(release.CaddyVersion)
|
||||
v.Patch++
|
||||
tags = append(tags, hubTag{Name: v.String() + "-alpine", Digest: "sha256:newer"})
|
||||
}
|
||||
return map[string][]hubTag{"results": tags}
|
||||
}
|
||||
|
||||
func bumpNum(s string) string {
|
||||
var n int
|
||||
fmt.Sscanf(s, "%d", &n)
|
||||
@@ -62,7 +86,7 @@ func bumpNum(s string) string {
|
||||
func TestRunReportsAllCurrentWhenNothingIsNewer(t *testing.T) {
|
||||
srv := releasesServer(t, false)
|
||||
defer srv.Close()
|
||||
code, err := run(context.Background(), srv.Client(), srv.URL, "", false)
|
||||
code, err := run(context.Background(), srv.Client(), srv.URL, srv.URL, "", false)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -74,7 +98,7 @@ func TestRunReportsAllCurrentWhenNothingIsNewer(t *testing.T) {
|
||||
func TestRunExits10WhenAPinIsBehind(t *testing.T) {
|
||||
srv := releasesServer(t, true)
|
||||
defer srv.Close()
|
||||
code, err := run(context.Background(), srv.Client(), srv.URL, "", false)
|
||||
code, err := run(context.Background(), srv.Client(), srv.URL, srv.URL, "", false)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -88,7 +112,7 @@ func TestRunErrorsOnABadStatus(t *testing.T) {
|
||||
http.Error(w, "nope", http.StatusInternalServerError)
|
||||
}))
|
||||
defer srv.Close()
|
||||
if _, err := run(context.Background(), srv.Client(), srv.URL, "", false); err == nil {
|
||||
if _, err := run(context.Background(), srv.Client(), srv.URL, srv.URL, "", false); err == nil {
|
||||
t.Errorf("a 500 from the releases API should be an error")
|
||||
}
|
||||
}
|
||||
@@ -113,3 +137,37 @@ func TestFetchReleasesSkipsDraftsAndKeepsPrereleaseFlag(t *testing.T) {
|
||||
t.Errorf("releases not carried through faithfully: %+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
// Caddy is behind when Docker Hub has a newer patch of its series, or when
|
||||
// its own version's tag now names another image; the moving tags, the
|
||||
// builder images and betas are never a move.
|
||||
func TestCheckCaddy(t *testing.T) {
|
||||
for _, c := range []struct {
|
||||
name string
|
||||
bump bool
|
||||
digest string
|
||||
stale bool
|
||||
latest string
|
||||
}{
|
||||
{"current", false, release.CaddyDigest, false, ""},
|
||||
{"newer patch", true, release.CaddyDigest, true, ""},
|
||||
{"rebuilt", false, "sha256:rebuilt", true, release.CaddyVersion + " rebuilt, now sha256:rebuilt"},
|
||||
} {
|
||||
t.Run(c.name, func(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
_ = json.NewEncoder(w).Encode(caddyTags(c.bump, c.digest))
|
||||
}))
|
||||
defer srv.Close()
|
||||
f, stale, err := checkCaddy(context.Background(), srv.Client(), srv.URL)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if stale != c.stale || (c.latest != "" && f.Latest != c.latest) {
|
||||
t.Errorf("stale = %v, finding %+v", stale, f)
|
||||
}
|
||||
if c.bump && (f.Latest == release.CaddyVersion || strings.Contains(f.Latest, "beta") || strings.HasPrefix(f.Latest, "9.")) {
|
||||
t.Errorf("moved to %s", f.Latest)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
+95
-18
@@ -23,9 +23,11 @@ import (
|
||||
"io"
|
||||
"math/big"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
@@ -40,15 +42,15 @@ import (
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/state"
|
||||
)
|
||||
|
||||
// Images are the defaults. They are tags rather than digests for now: the
|
||||
// registry is ours and the tags are immutable releases, and pinning digests
|
||||
// here would mean this program needing a release of its own for every one of
|
||||
// theirs.
|
||||
// Images are the defaults. The suite's own name one release each, by tag:
|
||||
// the registry is ours, but its tags can be pushed again by anyone holding a
|
||||
// push token, so they are a release's name rather than a guarantee of its
|
||||
// contents. Caddy, from Docker Hub, is pinned by digest (release.CaddyImage).
|
||||
const (
|
||||
DefaultServerImage = release.ServerImage
|
||||
DefaultConsoleImage = "registry.coffeylabs.org/inbuxa/inbuxa-admin:" + release.ConsoleVersion
|
||||
DefaultWebmailImage = "registry.coffeylabs.org/inbuxa/inbuxa-webmail:" + release.WebmailVersion
|
||||
DefaultCaddyImage = "docker.io/library/caddy:2-alpine"
|
||||
DefaultCaddyImage = release.CaddyImage
|
||||
DefaultSubnet = "172.31.253.0/24"
|
||||
// DefaultIPv6Subnet is a unique local /64 for the same network, on a
|
||||
// machine with IPv6 (#65). Nothing outside the machine ever sees it.
|
||||
@@ -322,7 +324,7 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
// listener on the host, so the router's is fitted again after one.
|
||||
if stack.PassThrough && (fitRouter || mv != nil) {
|
||||
log.Step("fitting the server's HTTPS to your web server's name router")
|
||||
srv := &jmap.Client{BaseURL: "http://" + hostFinalBind, Token: o.Key}
|
||||
srv := setupClient(onHost, jmap.Client{BaseURL: "http://" + hostFinalBind, Token: o.Key})
|
||||
if err := routeByName(ctx, srv, stack, onHost); err != nil {
|
||||
return nil, fmt.Errorf("fitting the server's HTTPS listener: %w", err)
|
||||
}
|
||||
@@ -343,7 +345,7 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
log.Info("%s", LogFilesHint)
|
||||
} else {
|
||||
log.Step("turning on the server's log files")
|
||||
srv := &jmap.Client{BaseURL: "http://" + hostFinalBind, Token: o.Key}
|
||||
srv := setupClient(onHost, jmap.Client{BaseURL: "http://" + hostFinalBind, Token: o.Key})
|
||||
if lerr := turnOnLogFiles(ctx, srv, onHost, mv != nil, cmp, log); lerr != nil {
|
||||
log.Info("could not turn on the log files the console's Logs page reads: %v", lerr)
|
||||
} else if !existing.LogFiles {
|
||||
@@ -382,12 +384,12 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
override := filepath.Join(os.TempDir(), "inbuxa-bootstrap.yaml")
|
||||
if err := os.WriteFile(override, []byte(
|
||||
"services:\n server:\n environment:\n INBUXA_RECOVERY_ADMIN: ${INBUXA_BOOTSTRAP_ADMIN:?}\n"), 0o600); err != nil {
|
||||
override, cleanup, err := setupOverride("inbuxa-bootstrap.yaml",
|
||||
"services:\n server:\n environment:\n INBUXA_RECOVERY_ADMIN: ${INBUXA_BOOTSTRAP_ADMIN:?}\n")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer os.Remove(override)
|
||||
defer cleanup()
|
||||
|
||||
log.Step("starting the mail server in bootstrap mode")
|
||||
serverURL := "http://" + stack.ServerBind
|
||||
@@ -416,7 +418,7 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
return nil, withLogs(ctx, err, srvLogs, "server")
|
||||
}
|
||||
|
||||
bootClient := &jmap.Client{BaseURL: serverURL, Username: "admin", Password: bootPass}
|
||||
bootClient := setupClient(onHost, jmap.Client{BaseURL: serverURL, Username: "admin", Password: bootPass})
|
||||
if err := bootClient.CheckBootstrapMode(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -449,12 +451,12 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
// does the rest of the setup, is removed when the setup ends, and expires
|
||||
// within the hour anyway, so a setup that stops halfway leaves nothing
|
||||
// that still works.
|
||||
basicOverride := filepath.Join(os.TempDir(), "inbuxa-basic-auth.yaml")
|
||||
if err := os.WriteFile(basicOverride, []byte(
|
||||
"services:\n server:\n environment:\n INBUXA_HTTP_BASIC_AUTH: all\n"), 0o600); err != nil {
|
||||
basicOverride, cleanupBasic, err := setupOverride("inbuxa-basic-auth.yaml",
|
||||
"services:\n server:\n environment:\n INBUXA_HTTP_BASIC_AUTH: all\n")
|
||||
if err != nil {
|
||||
return res, err
|
||||
}
|
||||
defer os.Remove(basicOverride)
|
||||
defer cleanupBasic()
|
||||
log.Step("restarting the mail server configured, to give the setup an API key")
|
||||
if onHost {
|
||||
if err := hs.Start(ctx, modeBasic, ""); err != nil {
|
||||
@@ -467,7 +469,7 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
return res, err
|
||||
}
|
||||
}
|
||||
adminBasic := &jmap.Client{BaseURL: serverURL, Username: admin.Username, Password: admin.Secret}
|
||||
adminBasic := setupClient(onHost, jmap.Client{BaseURL: serverURL, Username: admin.Username, Password: admin.Secret})
|
||||
var keyID, key string
|
||||
if err := waitFor(ctx, log, "the server to come back configured", 120*time.Second, func(ctx context.Context) error {
|
||||
var err error
|
||||
@@ -476,7 +478,7 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
}); err != nil {
|
||||
return res, withLogs(ctx, fmt.Errorf("an API key for the setup: %w", err), srvLogs, "server")
|
||||
}
|
||||
srv := &jmap.Client{BaseURL: serverURL, Token: key}
|
||||
srv := setupClient(onHost, jmap.Client{BaseURL: serverURL, Token: key})
|
||||
defer func() {
|
||||
ctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
|
||||
defer cancel()
|
||||
@@ -1044,3 +1046,78 @@ func password(n int) (string, error) {
|
||||
}
|
||||
return string(b), nil
|
||||
}
|
||||
|
||||
// setupOverride writes a compose override for one step of first boot, and
|
||||
// returns its path and what removes it. It goes in a new directory only root
|
||||
// can reach, never at a fixed name in the shared temporary directory, where
|
||||
// another local user could have put a file or a link of its own first.
|
||||
func setupOverride(name, content string) (string, func(), error) {
|
||||
dir, err := os.MkdirTemp("", "inbuxa-setup-")
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
}
|
||||
cleanup := func() { os.RemoveAll(dir) }
|
||||
path := filepath.Join(dir, name)
|
||||
f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
|
||||
if err == nil {
|
||||
_, err = f.WriteString(content)
|
||||
if cerr := f.Close(); err == nil {
|
||||
err = cerr
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
cleanup()
|
||||
return "", nil, err
|
||||
}
|
||||
return path, cleanup, nil
|
||||
}
|
||||
|
||||
// setupClient is a client for the server at a loopback address, carrying
|
||||
// the administrator's password or an API key. On the host those are ports
|
||||
// 8080 and 8081, which any local user may listen on while the installer
|
||||
// restarts the server: so before each request, whatever listens there must
|
||||
// be the server the unit started, or nothing is sent. In a container the
|
||||
// runtime publishes the port and nobody else can take it.
|
||||
//
|
||||
// The check is of the client's address at the time of each request, as
|
||||
// first boot moves its client from 8080 to 8081 once the listeners are
|
||||
// fitted.
|
||||
func setupClient(onHost bool, c jmap.Client) *jmap.Client {
|
||||
cl := &c
|
||||
if onHost {
|
||||
cl.Guard = func(ctx context.Context) error { return serversOwnListener(ctx, cl.BaseURL) }
|
||||
}
|
||||
return cl
|
||||
}
|
||||
|
||||
// serversOwnListener is nil when what listens on base's port is the host
|
||||
// server unit's main process.
|
||||
func serversOwnListener(ctx context.Context, base string) error {
|
||||
u, err := url.Parse(base)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
port, err := strconv.Atoi(u.Port())
|
||||
if err != nil {
|
||||
return fmt.Errorf("%s names no port", base)
|
||||
}
|
||||
pid := serverMainPID(ctx)
|
||||
if pid <= 0 {
|
||||
return fmt.Errorf("%s is not running", HostServerUnit)
|
||||
}
|
||||
if err := host.PortHeldBy(port, pid); err != nil {
|
||||
return fmt.Errorf("%w; the mail server is pid %d, so nothing was sent there", err, pid)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// serverMainPID is the host server unit's main process, or 0; a variable so
|
||||
// a test can stand in for systemd.
|
||||
var serverMainPID = func(ctx context.Context) int {
|
||||
out, err := exec.CommandContext(ctx, "systemctl", "show", "-p", "MainPID", "--value", HostServerUnit).Output()
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
pid, _ := strconv.Atoi(strings.TrimSpace(string(out)))
|
||||
return pid
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package apply
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// The server's user can write its home, so it can swap data/ for a symbolic
|
||||
// link to a directory of root's. Install runs again as root on every
|
||||
// converge or move, and must not then give that directory to the server's
|
||||
// user (INSTALLER-1).
|
||||
func TestServerDirsRefusesALinkedDataDir(t *testing.T) {
|
||||
deploy := t.TempDir()
|
||||
victim := t.TempDir() // a directory of root's, as far as the installer knows
|
||||
h := hostServer{deploy: deploy}
|
||||
if err := os.MkdirAll(h.home(), 0o750); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.Symlink(victim, filepath.Join(h.home(), "data")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var chowned []string
|
||||
defer func(f func(context.Context, ...string) error) { chownServer = f }(chownServer)
|
||||
chownServer = func(_ context.Context, args ...string) error {
|
||||
chowned = append(chowned, strings.Join(args, " "))
|
||||
return nil
|
||||
}
|
||||
|
||||
err := h.serverDirs(context.Background())
|
||||
if err == nil || !strings.Contains(err.Error(), "symbolic link") {
|
||||
t.Errorf("a data directory that is a symbolic link should be refused, got %v", err)
|
||||
}
|
||||
for _, c := range chowned {
|
||||
// chown follows a link it is given unless told -h, and always
|
||||
// through a trailing slash.
|
||||
if !strings.HasPrefix(c, "-h ") || strings.HasSuffix(c, "/") || strings.Contains(c, "/data") {
|
||||
t.Errorf("chown %s: would reach the link's target", c)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// A first install, and a converge over directories already right, make
|
||||
// both and give them to the server's user without following anything.
|
||||
func TestServerDirsMakesBoth(t *testing.T) {
|
||||
h := hostServer{deploy: t.TempDir()}
|
||||
var chowned []string
|
||||
defer func(f func(context.Context, ...string) error) { chownServer = f }(chownServer)
|
||||
chownServer = func(_ context.Context, args ...string) error {
|
||||
chowned = append(chowned, strings.Join(args, " "))
|
||||
return nil
|
||||
}
|
||||
for range 2 {
|
||||
chowned = nil
|
||||
if err := h.serverDirs(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
want := []string{
|
||||
"-h inbuxa:inbuxa " + h.home(),
|
||||
"-h inbuxa:inbuxa " + filepath.Join(h.home(), "data"),
|
||||
}
|
||||
if strings.Join(chowned, "|") != strings.Join(want, "|") {
|
||||
t.Errorf("chown %v, want %v", chowned, want)
|
||||
}
|
||||
if fi, err := os.Lstat(filepath.Join(h.home(), "data")); err != nil || !fi.IsDir() {
|
||||
t.Errorf("data/ is not a directory: %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -27,6 +27,7 @@ package apply
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
@@ -122,17 +123,65 @@ func (h hostServer) Install(ctx context.Context) (replaced bool, err error) {
|
||||
if err := os.Chmod(h.deploy, 0o711); err != nil {
|
||||
return false, err
|
||||
}
|
||||
for _, d := range []string{h.home(), h.DataPath()} {
|
||||
if err := os.MkdirAll(d, 0o750); err != nil {
|
||||
return false, err
|
||||
}
|
||||
if err := runQuiet(ctx, "chown", HostServerUser+":"+HostServerUser, d); err != nil {
|
||||
return false, err
|
||||
}
|
||||
if err := h.serverDirs(ctx); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return replaced, nil
|
||||
}
|
||||
|
||||
// chownServer runs chown; a variable so a test can watch it without root.
|
||||
var chownServer = func(ctx context.Context, args ...string) error {
|
||||
return runQuiet(ctx, "chown", args...)
|
||||
}
|
||||
|
||||
// serverDirs makes the server's home and its data directory and gives them
|
||||
// to the server's user. The home is in the deployment directory, which is
|
||||
// root's, but data/ is in the home, which that user can write: something
|
||||
// running as it could have put a symbolic link there, and following the
|
||||
// link would give it whatever directory the link names. So a data/ that is
|
||||
// not a plain directory is refused, and chown is given -h and no trailing
|
||||
// slash, so a link swapped in after the check is what changes owner, not
|
||||
// what it points at.
|
||||
func (h hostServer) serverDirs(ctx context.Context) error {
|
||||
for _, d := range []string{h.home(), filepath.Join(h.home(), "data")} {
|
||||
if err := plainDir(d, 0o750); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := chownServer(ctx, "-h", HostServerUser+":"+HostServerUser, d); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// plainDir makes dir when it is not there, and refuses one that is a
|
||||
// symbolic link or not a directory at all.
|
||||
func plainDir(dir string, mode os.FileMode) error {
|
||||
fi, err := os.Lstat(dir)
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
if err := os.Mkdir(dir, mode); err != nil && !errors.Is(err, os.ErrExist) {
|
||||
return err
|
||||
}
|
||||
fi, err = os.Lstat(dir)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return isPlainDir(dir, fi)
|
||||
}
|
||||
|
||||
func isPlainDir(dir string, fi os.FileInfo) error {
|
||||
switch {
|
||||
case fi.Mode()&os.ModeSymlink != 0:
|
||||
return fmt.Errorf("%s is a symbolic link, where the installer keeps a directory of the server's; "+
|
||||
"nothing was changed through it. Something running as %s may have put it there: look at where it points, "+
|
||||
"then move it aside and run this again", dir, HostServerUser)
|
||||
case !fi.IsDir():
|
||||
return fmt.Errorf("%s is not a directory", dir)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (h hostServer) fetchBinary(ctx context.Context) error {
|
||||
arch := runtime.GOARCH
|
||||
sum, ok := release.ServerSHA256[arch]
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package apply
|
||||
|
||||
import (
|
||||
"regexp"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// Everything this installer downloads as a file is checked against a
|
||||
// checksum in its source. Caddy, the proxy that holds the TLS keys, was
|
||||
// pulled by a floating tag from Docker Hub instead, so whoever could push
|
||||
// that tag chose what ran (INSTALLER-5). It is pinned by its digest now.
|
||||
func TestCaddyIsPinnedByDigest(t *testing.T) {
|
||||
if !regexp.MustCompile(`@sha256:[0-9a-f]{64}$`).MatchString(DefaultCaddyImage) {
|
||||
t.Errorf("DefaultCaddyImage = %q, not pinned by digest", DefaultCaddyImage)
|
||||
}
|
||||
}
|
||||
|
||||
// The suite's own images name one exact release, never a moving tag.
|
||||
func TestSuiteImagesNameAnExactRelease(t *testing.T) {
|
||||
exact := regexp.MustCompile(`:\d+\.\d+(\.\d+)*(-rc\.\d+)?$`)
|
||||
for _, img := range []string{DefaultServerImage, DefaultConsoleImage, DefaultWebmailImage} {
|
||||
if !exact.MatchString(img) {
|
||||
t.Errorf("%s does not name an exact release", img)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package apply
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/jmap"
|
||||
)
|
||||
|
||||
// squatter listens on loopback as this test's own process and records the
|
||||
// Authorization header of anything sent to it.
|
||||
func squatter(t *testing.T) (url string, seen func() []string) {
|
||||
t.Helper()
|
||||
var mu sync.Mutex
|
||||
var got []string
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
mu.Lock()
|
||||
got = append(got, r.Header.Get("Authorization"))
|
||||
mu.Unlock()
|
||||
w.WriteHeader(http.StatusServiceUnavailable)
|
||||
}))
|
||||
t.Cleanup(srv.Close)
|
||||
return srv.URL, func() []string {
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
return append([]string(nil), got...)
|
||||
}
|
||||
}
|
||||
|
||||
// During a host first boot or a move the server is restarted and then sent
|
||||
// the administrator's password or an API key on 127.0.0.1:8080 or :8081,
|
||||
// ports any local user may listen on while the server is down. What answers
|
||||
// there must be the server the unit started before anything is sent to it
|
||||
// (INSTALLER-4). Here the listener is this test's, and the unit's main
|
||||
// process is another one.
|
||||
func TestSetupCredentialsGoOnlyToTheServersOwnListener(t *testing.T) {
|
||||
url, seen := squatter(t)
|
||||
defer func(f func(context.Context) int) { serverMainPID = f }(serverMainPID)
|
||||
serverMainPID = func(context.Context) int { return os.Getppid() }
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
admin := setupClient(true, jmap.Client{BaseURL: url, Username: "admin", Password: "the-admin-password"})
|
||||
if _, _, err := admin.CreateAPIKey(ctx, "setup", time.Hour); err == nil {
|
||||
t.Error("an API key was made through a listener that isn't the server's")
|
||||
}
|
||||
keyed := setupClient(true, jmap.Client{BaseURL: url, Token: "the-api-key"})
|
||||
if err := keyed.HostListeners(ctx, hostFinalBind, false); err == nil {
|
||||
t.Error("the listeners were fitted through a listener that isn't the server's")
|
||||
}
|
||||
if got := seen(); len(got) != 0 {
|
||||
t.Errorf("credentials went to a listener that isn't the server's: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
// When the listener is the server's, the request goes through; and a
|
||||
// container's server, reached through the runtime's port, is not checked.
|
||||
func TestSetupCredentialsGoToTheServer(t *testing.T) {
|
||||
url, seen := squatter(t)
|
||||
defer func(f func(context.Context) int) { serverMainPID = f }(serverMainPID)
|
||||
serverMainPID = func(context.Context) int { return os.Getpid() }
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
setupClient(true, jmap.Client{BaseURL: url, Token: "k"}).Listeners(ctx)
|
||||
serverMainPID = func(context.Context) int { return os.Getppid() }
|
||||
setupClient(false, jmap.Client{BaseURL: url, Token: "k"}).Listeners(ctx)
|
||||
if got := seen(); len(got) != 2 {
|
||||
t.Errorf("want both requests sent, got %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
// First boot moves its client from 8080 to 8081 once the listeners are
|
||||
// fitted; the check follows it there.
|
||||
func TestSetupCredentialsCheckTheClientsCurrentAddress(t *testing.T) {
|
||||
old, _ := squatter(t)
|
||||
url, seen := squatter(t)
|
||||
defer func(f func(context.Context) int) { serverMainPID = f }(serverMainPID)
|
||||
serverMainPID = func(context.Context) int { return os.Getpid() }
|
||||
srv := setupClient(true, jmap.Client{BaseURL: old, Token: "k"})
|
||||
srv.BaseURL = url
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
srv.Listeners(ctx)
|
||||
if got := seen(); len(got) != 1 {
|
||||
t.Errorf("want the request sent to the new address, got %q", got)
|
||||
}
|
||||
// Both of the test's listeners are its own, so stand in a listener
|
||||
// that is not: a closed one, where nothing listens any more.
|
||||
srv.BaseURL = "http://127.0.0.1:1"
|
||||
if err := serversOwnListener(ctx, srv.BaseURL); err == nil {
|
||||
t.Error("a port nothing listens on passed the check")
|
||||
}
|
||||
}
|
||||
+52
-5
@@ -34,6 +34,7 @@ import (
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/compose"
|
||||
@@ -313,7 +314,7 @@ func (m *serverMove) toHost(ctx context.Context, stack compose.Stack, snippets b
|
||||
if err := m.cameBack(ctx, hostSetupBind, func() string { return hs.Logs(ctx, "server", 400) }); err != nil {
|
||||
return back(withLogs(ctx, err, hs, "server"))
|
||||
}
|
||||
srv := &jmap.Client{BaseURL: hostSetupBind, Token: m.key}
|
||||
srv := setupClient(true, jmap.Client{BaseURL: hostSetupBind, Token: m.key})
|
||||
if err := srv.HostListeners(ctx, hostFinalBind, m.local); err != nil {
|
||||
return back(fmt.Errorf("fitting the server's listeners to the host: %w", err))
|
||||
}
|
||||
@@ -459,6 +460,12 @@ func (m *serverMove) restoreHost(ctx context.Context, why error) error {
|
||||
// copied into it: what an earlier install on the host left there is
|
||||
// archived, never mixed with this.
|
||||
func (m *serverMove) clearForCopy(ctx context.Context, hs hostServer) error {
|
||||
data := filepath.Join(hs.home(), "data")
|
||||
if fi, err := os.Lstat(data); err == nil {
|
||||
if err := isPlainDir(data, fi); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
entries, _ := os.ReadDir(hs.DataPath())
|
||||
if len(entries) == 0 && !exists(hs.configPath()) {
|
||||
return nil
|
||||
@@ -507,8 +514,17 @@ func allowOnce(ctx context.Context, srv *jmap.Client, address, reason string) er
|
||||
// rewriteDataPath points the data store's description at its new home. Only
|
||||
// a path under the old home is changed: a store kept elsewhere (PostgreSQL,
|
||||
// a path the operator chose) is left alone.
|
||||
//
|
||||
// config.json is in the server's home, which the server's user can write, so
|
||||
// it is read without following a link and replaced by a rename, never
|
||||
// written through whatever is there.
|
||||
func rewriteDataPath(configPath, from, to string) error {
|
||||
b, err := os.ReadFile(configPath)
|
||||
f, err := openNoFollow(configPath)
|
||||
if err != nil {
|
||||
return fmt.Errorf("the server's configuration: %w", err)
|
||||
}
|
||||
b, err := io.ReadAll(f)
|
||||
f.Close()
|
||||
if err != nil {
|
||||
return fmt.Errorf("the server's configuration: %w", err)
|
||||
}
|
||||
@@ -525,11 +541,42 @@ func rewriteDataPath(configPath, from, to string) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
info, err := os.Stat(configPath)
|
||||
info, err := os.Lstat(configPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return os.WriteFile(configPath, out, info.Mode().Perm())
|
||||
return replaceFile(configPath, out, info.Mode().Perm())
|
||||
}
|
||||
|
||||
// openNoFollow opens a file for reading, refusing a symbolic link.
|
||||
func openNoFollow(path string) (*os.File, error) {
|
||||
f, err := os.OpenFile(path, os.O_RDONLY|syscall.O_NOFOLLOW, 0)
|
||||
if errors.Is(err, syscall.ELOOP) {
|
||||
return nil, fmt.Errorf("%s is a symbolic link, which the installer will not follow there", path)
|
||||
}
|
||||
return f, err
|
||||
}
|
||||
|
||||
// replaceFile puts content at path by writing a new file beside it and
|
||||
// renaming it over the old one: a link at path is replaced, not followed.
|
||||
func replaceFile(path string, content []byte, mode os.FileMode) error {
|
||||
tmp, err := os.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer os.Remove(tmp.Name())
|
||||
if _, err := tmp.Write(content); err != nil {
|
||||
tmp.Close()
|
||||
return err
|
||||
}
|
||||
if err := tmp.Chmod(mode); err != nil {
|
||||
tmp.Close()
|
||||
return err
|
||||
}
|
||||
if err := tmp.Close(); err != nil {
|
||||
return err
|
||||
}
|
||||
return os.Rename(tmp.Name(), path)
|
||||
}
|
||||
|
||||
// moveContents renames everything in src into dest, which is made if need
|
||||
@@ -553,7 +600,7 @@ func moveContents(src, dest string) error {
|
||||
}
|
||||
|
||||
func copyFile(src, dest string, mode os.FileMode) error {
|
||||
in, err := os.Open(src)
|
||||
in, err := openNoFollow(src)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -108,3 +108,28 @@ func TestMovedContentsArriveAndLeaveTheStageEmpty(t *testing.T) {
|
||||
t.Errorf("nothing to move is not an error: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// config.json is in the server's home, which its user can write. A move runs
|
||||
// as root and must not read or write through a link planted there
|
||||
// (INSTALLER-1).
|
||||
func TestRewriteDataPathRefusesALink(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
victim := filepath.Join(t.TempDir(), "root.json")
|
||||
body := `{"path":"/var/lib/inbuxa/x","secret":"root's"}`
|
||||
if err := os.WriteFile(victim, []byte(body), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cfg := filepath.Join(dir, "config.json")
|
||||
if err := os.Symlink(victim, cfg); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := rewriteDataPath(cfg, containerDataPath, "/var/lib/inbuxa/server/data/"); err == nil {
|
||||
t.Error("a config.json that is a symbolic link should be refused")
|
||||
}
|
||||
if b, _ := os.ReadFile(victim); string(b) != body {
|
||||
t.Errorf("written through the link: %s", b)
|
||||
}
|
||||
if err := copyFile(cfg, filepath.Join(dir, "staged.json"), 0o640); err == nil {
|
||||
t.Error("copying a config.json that is a symbolic link should be refused")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package apply
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// The setup's compose overrides are given to docker compose as root. Put at a
|
||||
// fixed name in the shared temporary directory, they could be planted
|
||||
// beforehand by any local user: as a link, to have root write over another
|
||||
// file, or as their own file, to rewrite it after root wrote it
|
||||
// (INSTALLER-3). Each now goes in a directory of its own that only root can
|
||||
// reach, and is gone after.
|
||||
func TestSetupOverrideIsNotAtAFixedNameInTmp(t *testing.T) {
|
||||
shared := t.TempDir()
|
||||
t.Setenv("TMPDIR", shared)
|
||||
victim := filepath.Join(t.TempDir(), "victim")
|
||||
if err := os.WriteFile(victim, []byte("root's\n"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, name := range []string{"inbuxa-bootstrap.yaml", "inbuxa-basic-auth.yaml"} {
|
||||
if err := os.Symlink(victim, filepath.Join(shared, name)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
path, cleanup, err := setupOverride("inbuxa-bootstrap.yaml", "services: {}\n")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if b, _ := os.ReadFile(victim); string(b) != "root's\n" {
|
||||
t.Errorf("written through a planted link: %q", b)
|
||||
}
|
||||
if b, _ := os.ReadFile(path); string(b) != "services: {}\n" {
|
||||
t.Errorf("the override holds %q", b)
|
||||
}
|
||||
dir := filepath.Dir(path)
|
||||
if dir == shared {
|
||||
t.Errorf("%s is straight in the shared temporary directory", path)
|
||||
} else if fi, err := os.Lstat(dir); err != nil || !fi.IsDir() || fi.Mode().Perm() != 0o700 {
|
||||
t.Errorf("%s should be a directory only its owner can reach: %v %v", dir, fi, err)
|
||||
}
|
||||
cleanup()
|
||||
if _, err := os.Lstat(dir); err == nil && dir != shared {
|
||||
t.Errorf("%s is left behind", dir)
|
||||
}
|
||||
}
|
||||
+107
-25
@@ -24,11 +24,16 @@ package cluster
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"os/exec"
|
||||
"os/user"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"syscall"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/topology"
|
||||
)
|
||||
@@ -142,7 +147,10 @@ func BuildPlan(c Config) (*Plan, error) {
|
||||
if _, err := os.Stat(dst); err != nil {
|
||||
return nil, fmt.Errorf("%s is not at %s and no secret_from says where to install it from", s.what, dst)
|
||||
}
|
||||
continue // already in place, left as it is
|
||||
continue // already in place, left as it is, and only the server reads it
|
||||
}
|
||||
if err := c.notALink(dst); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := os.Stat(s.from); err != nil {
|
||||
return nil, fmt.Errorf("%s: the source %s is not there", s.what, s.from)
|
||||
@@ -152,9 +160,14 @@ func BuildPlan(c Config) (*Plan, error) {
|
||||
|
||||
// The existing config.json, kept aside once so a node can be put back on
|
||||
// its old store. Only when there is one and no copy has been made before.
|
||||
if _, err := os.Stat(c.configPath()); err == nil {
|
||||
backup := c.configPath() + ".prev"
|
||||
if _, err := os.Stat(backup); err != nil {
|
||||
backup := c.configPath() + ".prev"
|
||||
for _, f := range []string{c.configPath(), backup} {
|
||||
if err := c.notALink(f); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
if _, err := os.Lstat(c.configPath()); err == nil {
|
||||
if _, err := os.Lstat(backup); err != nil {
|
||||
p.Backup = backup
|
||||
}
|
||||
}
|
||||
@@ -239,18 +252,26 @@ func orderDropIn(after []string) string {
|
||||
// Apply carries out the plan: the secrets, then the store config, then the
|
||||
// drop-ins, then a reload and restart. The order matters -- the config and its
|
||||
// secret are in place before the server is told to read them.
|
||||
//
|
||||
// The server's directory is the server user's, so whatever is in it may have
|
||||
// been put there by that user. Nothing is read or written there through a
|
||||
// symbolic link: config.json is read without following one, and every file
|
||||
// is written beside its place, given to the server's user by its descriptor,
|
||||
// and renamed into place, which replaces a link instead of writing through it.
|
||||
func Apply(ctx context.Context, p *Plan) error {
|
||||
c := p.Config
|
||||
run := c.run()
|
||||
owner := c.owner()
|
||||
|
||||
if p.Backup != "" {
|
||||
c.log("keeping the old store config at %s", p.Backup)
|
||||
if !c.DryRun {
|
||||
if err := copyFile(c.configPath(), p.Backup, 0o600); err != nil {
|
||||
return fmt.Errorf("saving the old config aside: %w", err)
|
||||
b, err := readNoFollow(c.configPath())
|
||||
if err == nil {
|
||||
err = putFile(p.Backup, b, 0o600, owner)
|
||||
}
|
||||
if c.User != "" {
|
||||
chown(ctx, run, c.User, p.Backup)
|
||||
if err != nil {
|
||||
return fmt.Errorf("saving the old config aside: %w", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -274,17 +295,22 @@ func Apply(ctx context.Context, p *Plan) error {
|
||||
if err := os.MkdirAll(filepath.Dir(w.Path), 0o750); err != nil {
|
||||
return err
|
||||
}
|
||||
if w.From != "" {
|
||||
if err := copyFile(w.From, w.Path, w.Mode); err != nil {
|
||||
return fmt.Errorf("installing %s from %s: %w", w.Path, w.From, err)
|
||||
}
|
||||
} else if err := os.WriteFile(w.Path, []byte(w.Content), w.Mode); err != nil {
|
||||
return err
|
||||
}
|
||||
// Secrets and the store config are the server's to read; the drop-ins
|
||||
// are root's, as systemd wants them.
|
||||
if c.User != "" && withinEtc(c, w.Path) {
|
||||
chown(ctx, run, c.User, w.Path)
|
||||
var to *ids
|
||||
if withinEtc(c, w.Path) {
|
||||
to = owner
|
||||
}
|
||||
if w.From != "" {
|
||||
b, err := os.ReadFile(w.From)
|
||||
if err == nil {
|
||||
err = putFile(w.Path, b, w.Mode, to)
|
||||
}
|
||||
if err != nil {
|
||||
return fmt.Errorf("installing %s from %s: %w", w.Path, w.From, err)
|
||||
}
|
||||
} else if err := putFile(w.Path, []byte(w.Content), w.Mode, to); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
@@ -312,21 +338,77 @@ func withinEtc(c Config, path string) bool {
|
||||
return err == nil && !strings.HasPrefix(rel, "..")
|
||||
}
|
||||
|
||||
func chown(ctx context.Context, run func(context.Context, string, ...string) error, user, path string) {
|
||||
// Best effort: ownership needs root, and a dry run or a test without it
|
||||
// should not fail over it. The mode is what keeps a secret unreadable.
|
||||
_ = run(ctx, "chown", user+":"+user, path)
|
||||
// notALink refuses a symbolic link at a path in the server's directory,
|
||||
// which the join would read or write as root.
|
||||
func (c Config) notALink(path string) error {
|
||||
if !withinEtc(c, path) {
|
||||
return nil // a path the operator chose, outside the server's directory
|
||||
}
|
||||
if fi, err := os.Lstat(path); err == nil && fi.Mode()&os.ModeSymlink != 0 {
|
||||
return fmt.Errorf("%s is a symbolic link, in a directory the server's user can write; the join "+
|
||||
"will not read or write through it. Look at where it points, then move it aside and run this again", path)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func copyFile(src, dst string, mode os.FileMode) error {
|
||||
b, err := os.ReadFile(src)
|
||||
// ids are the server user's, for the files written for it.
|
||||
type ids struct{ uid, gid int }
|
||||
|
||||
// owner is the server's user, or nil when none is named or it can't be
|
||||
// found. Ownership is best effort, as it needs root, and a dry run or a test
|
||||
// without it should not fail over it: the mode is what keeps a secret
|
||||
// unreadable.
|
||||
func (c Config) owner() *ids {
|
||||
if c.User == "" {
|
||||
return nil
|
||||
}
|
||||
u, err := user.Lookup(c.User)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
uid, err1 := strconv.Atoi(u.Uid)
|
||||
gid, err2 := strconv.Atoi(u.Gid)
|
||||
if err1 != nil || err2 != nil {
|
||||
return nil
|
||||
}
|
||||
return &ids{uid, gid}
|
||||
}
|
||||
|
||||
// readNoFollow reads a file, refusing a symbolic link.
|
||||
func readNoFollow(path string) ([]byte, error) {
|
||||
f, err := os.OpenFile(path, os.O_RDONLY|syscall.O_NOFOLLOW, 0)
|
||||
if err != nil {
|
||||
if errors.Is(err, syscall.ELOOP) {
|
||||
return nil, fmt.Errorf("%s is a symbolic link, which the join will not follow", path)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
defer f.Close()
|
||||
return io.ReadAll(f)
|
||||
}
|
||||
|
||||
// putFile writes content to a new file beside path, gives it its mode and
|
||||
// owner through the open file, and renames it over path.
|
||||
func putFile(path string, content []byte, mode os.FileMode, owner *ids) error {
|
||||
tmp, err := os.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.WriteFile(dst, b, mode); err != nil {
|
||||
defer os.Remove(tmp.Name())
|
||||
_, err = tmp.Write(content)
|
||||
if err == nil {
|
||||
err = tmp.Chmod(mode)
|
||||
}
|
||||
if err == nil && owner != nil {
|
||||
_ = tmp.Chown(owner.uid, owner.gid) // best effort, as above
|
||||
}
|
||||
if cerr := tmp.Close(); err == nil {
|
||||
err = cerr
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return os.Chmod(dst, mode)
|
||||
return os.Rename(tmp.Name(), path)
|
||||
}
|
||||
|
||||
// String renders the plan the way --dry-run shows it, in the installer's
|
||||
|
||||
@@ -7,8 +7,11 @@ import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"os"
|
||||
"os/user"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"syscall"
|
||||
"testing"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/topology"
|
||||
@@ -226,3 +229,141 @@ func TestNoServerDir(t *testing.T) {
|
||||
t.Error("a join before the server is installed should fail")
|
||||
}
|
||||
}
|
||||
|
||||
// victimFile is a file of root's outside the server's directory, which a
|
||||
// link planted in that directory points at.
|
||||
func victimFile(t *testing.T) string {
|
||||
t.Helper()
|
||||
p := filepath.Join(t.TempDir(), "shadow")
|
||||
if err := os.WriteFile(p, []byte("root:secret-hash\n"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
func untouched(t *testing.T, path string) {
|
||||
t.Helper()
|
||||
if b, _ := os.ReadFile(path); string(b) != "root:secret-hash\n" {
|
||||
t.Errorf("%s was written through a link: %q", path, b)
|
||||
}
|
||||
}
|
||||
|
||||
// The server's directory is its user's, so that user can replace config.json
|
||||
// or a secret with a symbolic link. A join runs as root and must neither
|
||||
// write through such a link nor copy what it points at into the rollback
|
||||
// copy (INSTALLER-1).
|
||||
func TestJoinRefusesLinksInTheServersDirectory(t *testing.T) {
|
||||
for _, name := range []string{"config.json", "config.json.prev", "pg.pw"} {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
cfg, _ := fixture(t, clusterNode(t, t.TempDir()))
|
||||
victim := victimFile(t)
|
||||
// A link to a file not there yet, for the one a join only
|
||||
// writes when it is missing.
|
||||
absent := filepath.Join(filepath.Dir(victim), "cron.d-x")
|
||||
link := filepath.Join(cfg.EtcDir, name)
|
||||
os.Remove(link)
|
||||
target := victim
|
||||
if name == "config.json.prev" {
|
||||
target = absent
|
||||
}
|
||||
if err := os.Symlink(target, link); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
p, err := BuildPlan(cfg)
|
||||
if err == nil {
|
||||
err = Apply(context.Background(), p)
|
||||
}
|
||||
if err == nil || !strings.Contains(err.Error(), "symbolic link") {
|
||||
t.Errorf("a link at %s should be refused, got %v", name, err)
|
||||
}
|
||||
untouched(t, victim)
|
||||
if _, err := os.Stat(absent); err == nil {
|
||||
t.Errorf("%s was created through a link", absent)
|
||||
}
|
||||
prev := cfg.configPath() + ".prev"
|
||||
if fi, err := os.Lstat(prev); err == nil && fi.Mode().IsRegular() {
|
||||
if b, _ := os.ReadFile(prev); strings.Contains(string(b), "secret-hash") {
|
||||
t.Error("the rollback copy holds the link's target")
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// A link swapped in after the plan was made, while the join runs, is
|
||||
// replaced, never written through.
|
||||
func TestJoinDoesNotWriteThroughALinkPlantedAfterThePlan(t *testing.T) {
|
||||
cfg, _ := fixture(t, clusterNode(t, t.TempDir()))
|
||||
p, err := BuildPlan(cfg)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
victim := victimFile(t)
|
||||
for _, name := range []string{"pg.pw", "nats.pw"} {
|
||||
if err := os.Symlink(victim, filepath.Join(cfg.EtcDir, name)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if err := Apply(context.Background(), p); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
untouched(t, victim)
|
||||
for _, name := range []string{"pg.pw", "nats.pw"} {
|
||||
fi, err := os.Lstat(filepath.Join(cfg.EtcDir, name))
|
||||
if err != nil || !fi.Mode().IsRegular() || fi.Mode().Perm() != 0o400 {
|
||||
t.Errorf("%s should be a plain file, mode 0400: %v %v", name, fi, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// With the server's user named, what a join writes beside config.json is
|
||||
// given to it. The current user stands in for it, so this runs without root.
|
||||
func TestJoinGivesItsFilesToTheServersUser(t *testing.T) {
|
||||
me, err := user.Current()
|
||||
if err != nil {
|
||||
t.Skip(err)
|
||||
}
|
||||
cfg, _ := fixture(t, clusterNode(t, t.TempDir()))
|
||||
cfg.User = me.Username
|
||||
p, err := BuildPlan(cfg)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := Apply(context.Background(), p); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, name := range []string{"config.json", "config.json.prev", "pg.pw"} {
|
||||
fi, err := os.Lstat(filepath.Join(cfg.EtcDir, name))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if st := fi.Sys().(*syscall.Stat_t); strconv.Itoa(int(st.Uid)) != me.Uid {
|
||||
t.Errorf("%s belongs to uid %d, want %s", name, st.Uid, me.Uid)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// A secret already in place that the join leaves alone may be a link the
|
||||
// operator made: only the server reads it, so it is not refused.
|
||||
func TestJoinLeavesALinkedSecretItDoesNotWrite(t *testing.T) {
|
||||
node := clusterNode(t, t.TempDir())
|
||||
cfg, _ := fixture(t, node)
|
||||
kept := filepath.Join(t.TempDir(), "pg.pw")
|
||||
if err := os.WriteFile(kept, []byte("pgpw"), 0o400); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.Symlink(kept, filepath.Join(cfg.EtcDir, "pg.pw")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cfg.Node.Store.SecretFrom = ""
|
||||
p, err := BuildPlan(cfg)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := Apply(context.Background(), p); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if fi, err := os.Lstat(filepath.Join(cfg.EtcDir, "pg.pw")); err != nil || fi.Mode()&os.ModeSymlink == 0 {
|
||||
t.Errorf("the operator's link should be left as it is: %v %v", fi, err)
|
||||
}
|
||||
}
|
||||
+28
-3
@@ -31,6 +31,7 @@ import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
@@ -348,10 +349,11 @@ func nodeNeed(f host.Facts) Need {
|
||||
}
|
||||
n.steps = []step{
|
||||
{"fetching node " + nodeVersion, func(ctx context.Context, log io.Writer) error {
|
||||
tmp := filepath.Join(os.TempDir(), "inbuxa-node.tar.xz")
|
||||
if err := fetchVerified(ctx, log, url, sum, tmp, 0o644); err != nil {
|
||||
tmp, cleanup, err := fetchToTemp(ctx, log, url, sum, "inbuxa-node.tar.xz")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer cleanup()
|
||||
// A different version unpacked over the old one would leave
|
||||
// the old one's files behind it.
|
||||
if err := os.RemoveAll("/opt/inbuxa/node"); err != nil {
|
||||
@@ -482,8 +484,13 @@ func fetchVerified(ctx context.Context, log io.Writer, url, want, dest string, m
|
||||
if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
|
||||
return err
|
||||
}
|
||||
// A new file, never one already at the name: what a failed run left is
|
||||
// removed first, and a link there is removed, not written through.
|
||||
tmp := dest + ".part"
|
||||
f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, mode)
|
||||
if err := os.Remove(tmp); err != nil && !errors.Is(err, os.ErrNotExist) {
|
||||
return err
|
||||
}
|
||||
f, err := os.OpenFile(tmp, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -569,3 +576,21 @@ func describeOS(o host.OSInfo) string {
|
||||
}
|
||||
return "this distribution"
|
||||
}
|
||||
|
||||
// fetchToTemp downloads url, checked against sum, to a temporary file named
|
||||
// name, and returns its path and what removes it. The file is in a new
|
||||
// directory only root can reach, so nobody else can put it there first or
|
||||
// change it between the checksum and its use.
|
||||
func fetchToTemp(ctx context.Context, log io.Writer, url, sum, name string) (string, func(), error) {
|
||||
dir, err := os.MkdirTemp("", "inbuxa-fetch-")
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
}
|
||||
cleanup := func() { os.RemoveAll(dir) }
|
||||
tmp := filepath.Join(dir, name)
|
||||
if err := fetchVerified(ctx, log, url, sum, tmp, 0o644); err != nil {
|
||||
cleanup()
|
||||
return "", nil, err
|
||||
}
|
||||
return tmp, cleanup, nil
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package deps
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func serve(t *testing.T, body string) (url, sum string) {
|
||||
t.Helper()
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
||||
io.WriteString(w, body)
|
||||
}))
|
||||
t.Cleanup(srv.Close)
|
||||
h := sha256.Sum256([]byte(body))
|
||||
return srv.URL, hex.EncodeToString(h[:])
|
||||
}
|
||||
|
||||
func plantedVictim(t *testing.T) string {
|
||||
t.Helper()
|
||||
p := filepath.Join(t.TempDir(), "victim")
|
||||
if err := os.WriteFile(p, []byte("root's\n"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
// Node is downloaded and then unpacked as root. At a fixed name in the
|
||||
// shared temporary directory, a local user could plant the file, or a link,
|
||||
// before the install, and change what root unpacks after its checksum
|
||||
// passed (INSTALLER-3). It now goes in a directory of its own, removed after.
|
||||
func TestNodeTarballIsNotAtAFixedNameInTmp(t *testing.T) {
|
||||
shared := t.TempDir()
|
||||
t.Setenv("TMPDIR", shared)
|
||||
victim := plantedVictim(t)
|
||||
for _, name := range []string{"inbuxa-node.tar.xz", "inbuxa-node.tar.xz.part"} {
|
||||
if err := os.Symlink(victim, filepath.Join(shared, name)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
url, sum := serve(t, "a node tarball")
|
||||
path, cleanup, err := fetchToTemp(context.Background(), io.Discard, url, sum, "inbuxa-node.tar.xz")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if b, _ := os.ReadFile(victim); string(b) != "root's\n" {
|
||||
t.Errorf("written through a planted link: %q", b)
|
||||
}
|
||||
if fi, err := os.Lstat(path); err != nil || !fi.Mode().IsRegular() {
|
||||
t.Errorf("%s should be a plain file: %v %v", path, fi, err)
|
||||
}
|
||||
dir := filepath.Dir(path)
|
||||
if dir == shared {
|
||||
t.Errorf("%s is straight in the shared temporary directory", path)
|
||||
} else if fi, err := os.Lstat(dir); err != nil || fi.Mode().Perm() != 0o700 {
|
||||
t.Errorf("%s should be a directory only its owner can reach: %v %v", dir, fi, err)
|
||||
}
|
||||
cleanup()
|
||||
if _, err := os.Lstat(path); err == nil {
|
||||
t.Errorf("%s is left behind", path)
|
||||
}
|
||||
}
|
||||
|
||||
// A download is written to a new file, never through whatever is at its
|
||||
// .part name already.
|
||||
func TestFetchVerifiedDoesNotWriteThroughAPartLink(t *testing.T) {
|
||||
dest := filepath.Join(t.TempDir(), "file")
|
||||
victim := plantedVictim(t)
|
||||
if err := os.Symlink(victim, dest+".part"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
url, sum := serve(t, "the download")
|
||||
if err := fetchVerified(context.Background(), io.Discard, url, sum, dest, 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if b, _ := os.ReadFile(victim); string(b) != "root's\n" {
|
||||
t.Errorf("written through a planted link: %q", b)
|
||||
}
|
||||
if fi, err := os.Lstat(dest); err != nil || !fi.Mode().IsRegular() {
|
||||
t.Errorf("%s should be a plain file: %v %v", dest, fi, err)
|
||||
}
|
||||
}
|
||||
+53
-14
@@ -477,6 +477,34 @@ func surveyPort(n int, for_ string) Port {
|
||||
// /proc, which means it only sees the whole truth as root; a guess is better
|
||||
// than nothing and the caller treats it as one.
|
||||
func holderOf(port int) string {
|
||||
inodes := listenInodes(port)
|
||||
if len(inodes) == 0 {
|
||||
return ""
|
||||
}
|
||||
procs, err := filepath.Glob("/proc/[0-9]*/fd/*")
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
for _, fd := range procs {
|
||||
link, err := os.Readlink(fd)
|
||||
if err != nil || !strings.HasPrefix(link, "socket:[") {
|
||||
continue
|
||||
}
|
||||
inode := strings.TrimSuffix(strings.TrimPrefix(link, "socket:["), "]")
|
||||
if !inodes[inode] {
|
||||
continue
|
||||
}
|
||||
pid := strings.Split(fd, "/")[2]
|
||||
if comm, err := os.ReadFile("/proc/" + pid + "/comm"); err == nil {
|
||||
return strings.TrimSpace(string(comm)) + " (pid " + pid + ")"
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// listenInodes are the socket inodes listening on a TCP port, on any
|
||||
// address, IPv4 or IPv6.
|
||||
func listenInodes(port int) map[string]bool {
|
||||
inodes := map[string]bool{}
|
||||
for _, tab := range []string{"/proc/net/tcp", "/proc/net/tcp6"} {
|
||||
file, err := os.Open(tab)
|
||||
@@ -505,28 +533,35 @@ func holderOf(port int) string {
|
||||
}
|
||||
file.Close()
|
||||
}
|
||||
return inodes
|
||||
}
|
||||
|
||||
// portHeldBy is nil when every socket listening on port is the process
|
||||
// pid's own, and says why not otherwise.
|
||||
func portHeldBy(port, pid int) error {
|
||||
inodes := listenInodes(port)
|
||||
if len(inodes) == 0 {
|
||||
return ""
|
||||
return fmt.Errorf("nothing listens on port %d yet", port)
|
||||
}
|
||||
procs, err := filepath.Glob("/proc/[0-9]*/fd/*")
|
||||
fds, err := os.ReadDir(fmt.Sprintf("/proc/%d/fd", pid))
|
||||
if err != nil {
|
||||
return ""
|
||||
return fmt.Errorf("the sockets of pid %d: %w", pid, err)
|
||||
}
|
||||
for _, fd := range procs {
|
||||
link, err := os.Readlink(fd)
|
||||
for _, fd := range fds {
|
||||
link, err := os.Readlink(fmt.Sprintf("/proc/%d/fd/%s", pid, fd.Name()))
|
||||
if err != nil || !strings.HasPrefix(link, "socket:[") {
|
||||
continue
|
||||
}
|
||||
inode := strings.TrimSuffix(strings.TrimPrefix(link, "socket:["), "]")
|
||||
if !inodes[inode] {
|
||||
continue
|
||||
}
|
||||
pid := strings.Split(fd, "/")[2]
|
||||
if comm, err := os.ReadFile("/proc/" + pid + "/comm"); err == nil {
|
||||
return strings.TrimSpace(string(comm)) + " (pid " + pid + ")"
|
||||
}
|
||||
delete(inodes, strings.TrimSuffix(strings.TrimPrefix(link, "socket:["), "]"))
|
||||
}
|
||||
return ""
|
||||
if len(inodes) == 0 {
|
||||
return nil
|
||||
}
|
||||
who := holderOf(port)
|
||||
if who == "" {
|
||||
who = "another process"
|
||||
}
|
||||
return fmt.Errorf("port %d is held by %s, not pid %d", port, who, pid)
|
||||
}
|
||||
|
||||
func memoryMB() int {
|
||||
@@ -603,3 +638,7 @@ func Systemd() bool { return isSystemd() }
|
||||
// HolderOf names the process listening on a port, as well as /proc lets it:
|
||||
// "postfix (pid 812)", or "" when it can't tell.
|
||||
func HolderOf(port int) string { return holderOf(port) }
|
||||
|
||||
// PortHeldBy is nil when everything listening on a TCP port is process
|
||||
// pid's, and says what else is there otherwise.
|
||||
func PortHeldBy(port, pid int) error { return portHeldBy(port, pid) }
|
||||
@@ -36,6 +36,9 @@ type Client struct {
|
||||
// /jmap (contract C-23), so a configured server takes an API key only.
|
||||
Token string
|
||||
HTTP *http.Client
|
||||
// Guard, when set, is asked before every request: an error from it
|
||||
// stops the request before any credential is sent.
|
||||
Guard func(context.Context) error
|
||||
}
|
||||
|
||||
// Call is one method call in a request.
|
||||
@@ -77,6 +80,13 @@ func (e *HTTPError) Error() string {
|
||||
return fmt.Sprintf("HTTP %d: %s", e.Status, strings.TrimSpace(e.Body))
|
||||
}
|
||||
|
||||
func (c *Client) guard(ctx context.Context) error {
|
||||
if c.Guard == nil {
|
||||
return nil
|
||||
}
|
||||
return c.Guard(ctx)
|
||||
}
|
||||
|
||||
func (c *Client) httpClient() *http.Client {
|
||||
if c.HTTP != nil {
|
||||
return c.HTTP
|
||||
@@ -105,6 +115,9 @@ func (c *Client) do(ctx context.Context, using []string, calls ...Call) ([]Respo
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := c.guard(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if c.Token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+c.Token)
|
||||
} else {
|
||||
|
||||
@@ -39,6 +39,9 @@ func (c *Client) AccountID(ctx context.Context) (string, error) {
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if err := c.guard(ctx); err != nil {
|
||||
return "", err
|
||||
}
|
||||
if c.Token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+c.Token)
|
||||
} else {
|
||||
|
||||
+29
-10
@@ -243,8 +243,7 @@ func Install(ctx context.Context, p Plan, o Options, log Log) error {
|
||||
|
||||
if p.Join {
|
||||
log.Step("joining")
|
||||
out, err := exec.CommandContext(ctx, "runuser", "-u", User, "--",
|
||||
Binary, "join", o.Token, "--state", StateDir).CombinedOutput()
|
||||
out, err := asRelay(ctx, "join", o.Token, "--state", StateDir).CombinedOutput()
|
||||
if err != nil {
|
||||
return fmt.Errorf("the join was refused: %s", strings.TrimSpace(strings.TrimPrefix(string(out), "inbuxa-relay: ")))
|
||||
}
|
||||
@@ -320,8 +319,8 @@ func putBinary(ctx context.Context, p Plan, log Log) error {
|
||||
fmt.Fprintln(log.Out(), " signed by an inbuxa release key")
|
||||
}
|
||||
// Run before it is put in place, as the relay tries a binary before an
|
||||
// upgrade.
|
||||
got := installedVersion(ctx, path)
|
||||
// upgrade. Run as root: it is the checked file, in root's own directory.
|
||||
got := versionOf(exec.CommandContext(ctx, path, "--version"))
|
||||
if got == "" {
|
||||
out, _ := exec.CommandContext(ctx, path, "--version").CombinedOutput()
|
||||
return fmt.Errorf("the relay binary does not run here: %s", strings.TrimSpace(string(out)))
|
||||
@@ -356,7 +355,7 @@ func Status(ctx context.Context, out io.Writer) bool {
|
||||
enabled, _ := exec.CommandContext(ctx, "systemctl", "is-enabled", Unit).Output()
|
||||
fmt.Fprintf(out, "%s: %s, %s at boot\n", Unit, state, strings.TrimSpace(string(enabled)))
|
||||
fmt.Fprintf(out, "%s: inbuxa-relay %s (this installer installs %s)\n\n", Binary, v, release.RelayVersion())
|
||||
cmd := exec.CommandContext(ctx, "runuser", "-u", User, "--", Binary, "status", "--state", StateDir)
|
||||
cmd := asRelay(ctx, "status", "--state", StateDir)
|
||||
cmd.Stdout, cmd.Stderr = out, out
|
||||
cmd.Run()
|
||||
return true
|
||||
@@ -394,11 +393,11 @@ func Uninstall(ctx context.Context, purge, discardHeld bool, log Log) error {
|
||||
}
|
||||
if purge {
|
||||
if _, err := os.Stat(Binary); err == nil {
|
||||
args := []string{"-u", User, "--", Binary, "reset", "--state", StateDir}
|
||||
args := []string{"reset", "--state", StateDir}
|
||||
if discardHeld {
|
||||
args = append(args, "--discard-held")
|
||||
}
|
||||
out, err := exec.CommandContext(ctx, "runuser", args...).CombinedOutput()
|
||||
out, err := asRelay(ctx, args...).CombinedOutput()
|
||||
if err != nil {
|
||||
msg := strings.TrimSpace(strings.TrimPrefix(string(out), "inbuxa-relay: "))
|
||||
msg = strings.ReplaceAll(msg, "Run `inbuxa-relay reset --discard-held`", "Add --discard-held")
|
||||
@@ -509,16 +508,36 @@ func unitLinkListen(unit string) string {
|
||||
return ""
|
||||
}
|
||||
|
||||
// installedVersion is the version a relay binary says it is, or "" when it
|
||||
// isn't there or doesn't run.
|
||||
// installedVersion is the version the installed relay binary at path says
|
||||
// it is, or "" when it isn't there or doesn't run. It is asked as the relay
|
||||
// user: the binary is that user's to replace, so root never runs it.
|
||||
func installedVersion(ctx context.Context, path string) string {
|
||||
out, err := exec.CommandContext(ctx, path, "--version").Output()
|
||||
return versionOf(asRelayRun(ctx, path, "--version"))
|
||||
}
|
||||
|
||||
func versionOf(cmd *exec.Cmd) string {
|
||||
out, err := cmd.Output()
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return parseVersionOutput(string(out))
|
||||
}
|
||||
|
||||
// asRelay runs the installed binary with args as the relay user, the one
|
||||
// that owns it and may have replaced it, never as root.
|
||||
func asRelay(ctx context.Context, args ...string) *exec.Cmd {
|
||||
return asRelayRun(ctx, Binary, args...)
|
||||
}
|
||||
|
||||
// asRelayRun is asRelay for the binary at path. It runs in a session of its
|
||||
// own, without root's terminal as its controlling one, so it can't push
|
||||
// input into the shell that ran the installer.
|
||||
func asRelayRun(ctx context.Context, path string, args ...string) *exec.Cmd {
|
||||
cmd := exec.CommandContext(ctx, "runuser", append([]string{"-u", User, "--", path}, args...)...)
|
||||
cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
|
||||
return cmd
|
||||
}
|
||||
|
||||
func parseVersionOutput(out string) string {
|
||||
f := strings.Fields(out)
|
||||
if len(f) != 2 || f[0] != "inbuxa-relay" {
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package relay
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// The installed binary is the relay user's to replace (an upgrade from the
|
||||
// console does), so whatever is there may be that user's own program. relay
|
||||
// status and relay install, which run as root, ask it its version, and must
|
||||
// not run it as root to do so (INSTALLER-2). Here the stand-in records that
|
||||
// it ran: run as the relay user through runuser, it never does, since this
|
||||
// test is not root or the relay user cannot reach a file in its temp dir.
|
||||
func TestInstalledVersionDoesNotRunTheBinaryItself(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
ran := filepath.Join(dir, "ran")
|
||||
bin := filepath.Join(dir, "inbuxa-relay")
|
||||
script := "#!/bin/sh\ntouch " + ran + "\necho inbuxa-relay 27.1.0\n"
|
||||
if err := os.WriteFile(bin, []byte(script), 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
installedVersion(context.Background(), bin)
|
||||
if _, err := os.Stat(ran); err == nil {
|
||||
t.Error("installedVersion ran the relay user's binary as the installer's own user")
|
||||
}
|
||||
}
|
||||
|
||||
// Everything the installer runs of the installed binary goes through
|
||||
// runuser as the relay user, in a session of its own.
|
||||
func TestTheInstalledBinaryRunsAsTheRelayUser(t *testing.T) {
|
||||
for _, cmd := range []*exec.Cmd{
|
||||
asRelay(context.Background(), "status", "--state", StateDir),
|
||||
asRelayRun(context.Background(), Binary, "--version"),
|
||||
} {
|
||||
if len(cmd.Args) < 5 || filepath.Base(cmd.Path) != "runuser" ||
|
||||
strings.Join(cmd.Args[:5], " ") != "runuser -u "+User+" -- "+Binary {
|
||||
t.Errorf("runs %v, not the binary as %s", cmd.Args, User)
|
||||
}
|
||||
if cmd.SysProcAttr == nil || !cmd.SysProcAttr.Setsid {
|
||||
t.Errorf("%v keeps the installer's controlling terminal", cmd.Args)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -30,6 +30,23 @@ const ServerVersion = "27.1-rc.25"
|
||||
// ServerImage is that release as a container image.
|
||||
const ServerImage = "registry.coffeylabs.org/inbuxa/inbuxa-server:" + ServerVersion
|
||||
|
||||
// Caddy, the proxy in front of the console and the webmail, which holds
|
||||
// their TLS keys, from Docker Hub. It is pinned by the digest of its image
|
||||
// index, as the binaries are by their checksums: a tag there moves, and even
|
||||
// a full version's tag is pushed again when its image is rebuilt (for a new
|
||||
// Alpine, say). CaddyVersion is the tag the digest was read from, X.Y.Z of
|
||||
// caddy:X.Y.Z-alpine, which pin-check watches for a newer one or a rebuild.
|
||||
// The digest is read with
|
||||
// `docker buildx imagetools inspect docker.io/library/caddy:<version>-alpine`.
|
||||
const (
|
||||
CaddyVersion = "2.11.9"
|
||||
CaddyDigest = "sha256:003a97808e781aa9f7e75cc2f43d34d461099031faf5e20faefb9f61126836f0"
|
||||
)
|
||||
|
||||
// CaddyImage is that image, by its digest alone, which every runtime the
|
||||
// installer drives reads the same way.
|
||||
const CaddyImage = "docker.io/library/caddy@" + CaddyDigest
|
||||
|
||||
// ServerSHA256 is the SHA-256 of each architecture's release tarball, copied
|
||||
// from the release's SHA256SUMS when the version was moved and checked here
|
||||
// rather than fetched beside the download: a checksum that arrives with the
|
||||
|
||||
Reference in new issue
Block a user