Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

Exercise CLI API redirect confidentiality

pulse-triage[bot]7966a309f033
diff --git a/pkg/pulsecli/api_redirect_test.go b/pkg/pulsecli/api_redirect_test.go
new file mode 100644
index 0000000000..6923692681
--- /dev/null
+++ b/pkg/pulsecli/api_redirect_test.go
@@ -0,0 +1,173 @@
+package pulsecli
+
+import (
+ "bytes"
+ "context"
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+ "time"
+)
+
+// These are the registered commands, not a second implementation of their
+// HTTP requests. All credentials and action contents are synthetic.
+type cliRedirectCommand struct {
+ name string
+ args []string
+ method string
+ path string
+}
+
+func cliRedirectCommands() []cliRedirectCommand {
+ return []cliRedirectCommand{
+ {"fleet", []string{"fleet", "connections"}, http.MethodGet, "/api/connections"},
+ {"plan", []string{"actions", "plan", "--request-id", "synthetic-request", "--resource-id", "vm:42", "--capability", "restart", "--reason", "synthetic-private-action"}, http.MethodPost, "/api/actions/plan"},
+ {"decide", []string{"actions", "decide", "--action-id", "synthetic-action", "--outcome", "approved", "--reason", "synthetic-private-action"}, http.MethodPost, "/api/actions/synthetic-action/decision"},
+ {"execute", []string{"actions", "execute", "--action-id", "synthetic-action", "--reason", "synthetic-private-action"}, http.MethodPost, "/api/actions/synthetic-action/execute"},
+ {"capabilities", []string{"actions", "capabilities", "--resource-id", "vm:42"}, http.MethodGet, "/api/resources/vm:42/facets"},
+ {"audit", []string{"actions", "audit"}, http.MethodGet, "/api/audit/actions"},
+ {"events", []string{"actions", "events", "--action-id", "synthetic-action"}, http.MethodGet, "/api/audit/actions/synthetic-action/events"},
+ }
+}
+
+func executeCLIRedirectCommand(t *testing.T, command cliRedirectCommand, baseURL string, client HTTPDoer) (string, string, error) {
+ t.Helper()
+ getenv := func(key string) string {
+ switch key {
+ case "PULSE_API_URL":
+ return baseURL
+ case "PULSE_API_TOKEN":
+ return "synthetic-cli-token"
+ default:
+ return ""
+ }
+ }
+ root := NewRootCommand(CommandSpec{Use: "pulse"}, RuntimeSpec{}, CommandDeps{
+ Actions: &ActionsDeps{HTTPClient: client, Getenv: getenv},
+ Fleet: &FleetDeps{HTTPClient: client, Getenv: getenv},
+ })
+ var stdout, stderr bytes.Buffer
+ root.SetOut(&stdout)
+ root.SetErr(&stderr)
+ root.SetArgs(command.args)
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ defer cancel()
+ err := root.ExecuteContext(ctx)
+ return stdout.String(), stderr.String(), err
+}
+
+type cliRedirectRequest struct {
+ path string
+ method string
+ authOK bool
+ body string
+}
+
+func recordCLIRedirectRequest(r *http.Request) cliRedirectRequest {
+ body, _ := io.ReadAll(io.LimitReader(r.Body, 4096))
+ return cliRedirectRequest{
+ path: r.URL.Path, method: r.Method,
+ authOK: r.Header.Get("Authorization") == "Bearer synthetic-cli-token",
+ body: string(body),
+ }
+}
+
+func TestCLIAPICommandsKeepRedirectsWithinOrigin(t *testing.T) {
+ for _, injected := range []bool{false, true} {
+ for _, command := range cliRedirectCommands() {
+ for _, status := range []int{301, 302, 303, 307, 308} {
+ t.Run(fmt.Sprintf("injected-%t/%s/%d", injected, command.name, status), func(t *testing.T) {
+ foreign := make(chan cliRedirectRequest, 2)
+ sink := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ foreign <- recordCLIRedirectRequest(r)
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = io.WriteString(w, `{}`)
+ }))
+ defer sink.Close()
+ sourceRequests := make(chan cliRedirectRequest, 2)
+ source := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ sourceRequests <- recordCLIRedirectRequest(r)
+ http.Redirect(w, r, sink.URL+"/synthetic-private-destination?value=synthetic-private-query", status)
+ }))
+ defer source.Close()
+ var client HTTPDoer
+ if injected {
+ client = source.Client()
+ }
+ stdout, stderr, err := executeCLIRedirectCommand(t, command, source.URL, client)
+ if len(sourceRequests) != 1 {
+ t.Fatalf("source requests = %d, want one", len(sourceRequests))
+ }
+ original := <-sourceRequests
+ if original.path != command.path || original.method != command.method || !original.authOK {
+ t.Fatalf("original request path=%s method=%s bearer=%t", original.path, original.method, original.authOK)
+ }
+ if command.method == http.MethodPost && !strings.Contains(original.body, "synthetic-private-action") {
+ t.Fatal("action request did not exercise the replayable body")
+ }
+ foreignCount := len(foreign)
+ foreignBearer, replayedBody := false, false
+ for len(foreign) > 0 {
+ request := <-foreign
+ foreignBearer = foreignBearer || request.authOK
+ replayedBody = replayedBody || strings.Contains(request.body, "synthetic-private-action")
+ }
+ // Counts/booleans make the pre-repair failure useful evidence
+ // without printing bearer values or request bodies.
+ t.Logf("foreign requests=%d bearer=%t replayed-body=%t", foreignCount, foreignBearer, replayedBody)
+ if err == nil || !strings.Contains(err.Error(), "set the final Pulse base URL") || foreignCount != 0 {
+ t.Errorf("redirect must refuse before a foreign request; err=%v", err)
+ }
+ combined := stdout + stderr + fmt.Sprint(err)
+ for _, private := range []string{"synthetic-cli-token", "synthetic-private-destination", "synthetic-private-query", "synthetic-private-action"} {
+ if strings.Contains(combined, private) {
+ t.Errorf("command output disclosed %s", private)
+ }
+ }
+ if stdout != "" {
+ t.Error("refused redirect printed a successful API result")
+ }
+ })
+ }
+ }
+ }
+}
+
+func TestCLIAPICommandsPreserveSameOriginTLSRedirects(t *testing.T) {
+ for _, command := range cliRedirectCommands() {
+ for _, status := range []int{307, 308} {
+ t.Run(fmt.Sprintf("%s/%d", command.name, status), func(t *testing.T) {
+ requests := make(chan cliRedirectRequest, 3)
+ server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ requests <- recordCLIRedirectRequest(r)
+ if r.URL.Path == command.path {
+ http.Redirect(w, r, "/proxy"+command.path, status)
+ return
+ }
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = io.WriteString(w, `{}`)
+ }))
+ defer server.Close()
+ client := server.Client() // Keep this caller's actual TLS trust.
+ client.Timeout = 3 * time.Second
+ stdout, _, err := executeCLIRedirectCommand(t, command, server.URL, client)
+ if err != nil {
+ t.Fatalf("same-origin TLS command failed: %v", err)
+ }
+ if stdout == "" || len(requests) != 2 {
+ t.Fatalf("output=%t requests=%d, want JSON and two requests", stdout != "", len(requests))
+ }
+ original, redirected := <-requests, <-requests
+ if redirected.path != "/proxy"+command.path || redirected.method != command.method || !original.authOK || !redirected.authOK || redirected.body != original.body {
+ t.Fatalf("same-origin request changed: path=%s method=%s original-bearer=%t redirected-bearer=%t equal-body=%t", redirected.path, redirected.method, original.authOK, redirected.authOK, redirected.body == original.body)
+ }
+ if client.CheckRedirect != nil || client.Timeout != 3*time.Second {
+ t.Fatal("caller HTTP client policy was mutated")
+ }
+ })
+ }
+ }
+}