Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

8.5 KB
Raw Blame
package runtime

import (
	"bytes"
	"context"
	"log/slog"
	"strings"
	"testing"

	"github.com/chromedp/cdproto/fetch"
	"github.com/pinchtab/pinchtab/internal/config"
)

func TestProxyAuthEnabled_DisabledWhenNoCredentials(t *testing.T) {
	cases := []struct {
		name string
		p    config.BrowserProxyConfig
	}{
		{
			name: "zero value",
			p:    config.BrowserProxyConfig{},
		},
		{
			name: "server only, no username",
			p:    config.BrowserProxyConfig{Server: "http://proxy.example:8080"},
		},
		{
			name: "server + password but no username (validator would reject)",
			p:    config.BrowserProxyConfig{Server: "http://proxy.example:8080", Password: "secret"},
		},
		{
			name: "empty server, credentials populated",
			p:    config.BrowserProxyConfig{Username: "user", Password: "pw"},
		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			if ProxyAuthEnabled(tc.p) {
				t.Fatalf("ProxyAuthEnabled(%+v) = true, want false", tc.p.Redacted())
			}
		})
	}
}

func TestProxyAuthEnabled_EnabledWhenCredentialsPresent(t *testing.T) {
	p := config.BrowserProxyConfig{
		Server:   "http://proxy.example:8080",
		Username: "user",
		Password: "pw",
	}
	if !ProxyAuthEnabled(p) {
		t.Fatalf("ProxyAuthEnabled(%+v) = false, want true", p.Redacted())
	}
}

// Cancelled context ensures the function bails before any CDP call.
func TestEnableProxyAuth_NoopWhenDisabled(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	if err := EnableProxyAuth(ctx, config.BrowserProxyConfig{}, nil); err != nil {
		t.Fatalf("EnableProxyAuth on disabled proxy returned %v, want nil", err)
	}
	if err := EnableProxyAuth(ctx, config.BrowserProxyConfig{Server: "http://p:1"}, nil); err != nil {
		t.Fatalf("EnableProxyAuth on credential-less proxy returned %v, want nil", err)
	}
}

func TestAuthChallengeResponse_ProvidesCredentialsForProxyChallenge(t *testing.T) {
	e := &fetch.EventAuthRequired{
		AuthChallenge: &fetch.AuthChallenge{Source: fetch.AuthChallengeSourceProxy},
	}
	resp := AuthChallengeResponse(e, "user", "pw")
	if resp.Response != fetch.AuthChallengeResponseResponseProvideCredentials {
		t.Fatalf("Response = %q, want ProvideCredentials", resp.Response)
	}
	if resp.Username != "user" || resp.Password != "pw" {
		t.Fatalf("credentials = %q/%q, want user/pw", resp.Username, resp.Password)
	}
}

func TestAuthChallengeResponse_YieldsNonProxyChallenges(t *testing.T) {
	cases := []struct {
		name string
		e    *fetch.EventAuthRequired
	}{
		{name: "nil event", e: nil},
		{name: "nil challenge", e: &fetch.EventAuthRequired{}},
		{
			name: "server challenge (WWW-Authenticate)",
			e: &fetch.EventAuthRequired{
				AuthChallenge: &fetch.AuthChallenge{Source: fetch.AuthChallengeSourceServer},
			},
		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			resp := AuthChallengeResponse(tc.e, "user", "pw")
			if resp.Response != fetch.AuthChallengeResponseResponseDefault {
				t.Fatalf("Response = %q, want Default", resp.Response)
			}
			if resp.Username != "" || resp.Password != "" {
				t.Fatalf("credentials leaked into non-proxy challenge response: %q/%q", resp.Username, resp.Password)
			}
		})
	}
}

func TestProxyAuth_PasswordNotLoggedViaRedacted(t *testing.T) {
	p := config.BrowserProxyConfig{
		Server:   "http://proxy.example:8080",
		Username: "user",
		Password: "super-secret",
	}
	r := p.Redacted()
	if r.Password == p.Password {
		t.Fatalf("Redacted() did not mask password: %q", r.Password)
	}
	if r.Password == "" {
		t.Fatalf("Redacted() should keep a placeholder for non-empty passwords")
	}
}

func TestRemoteProxyAuthRequiresExplicitOptIn(t *testing.T) {
	cfg := &config.RuntimeConfig{
		Proxy: config.BrowserProxyConfig{
			Server:   "http://proxy.example:8080",
			Username: "user",
			Password: "super-secret",
		},
	}

	var err error
	logs := captureSlog(t, func() {
		err = requireRemoteProxyAuthOptIn("ws://203.0.113.10:9222/devtools/browser/abc", cfg)
	})
	if err == nil {
		t.Fatal("expected remote proxy auth forwarding to be refused")
	}
	if !strings.Contains(err.Error(), "security.attach.forwardProxyAuth=true") {
		t.Fatalf("error should mention explicit opt-in, got %v", err)
	}
	if !strings.Contains(logs, "remote_cdp.proxy_auth_blocked") || !strings.Contains(logs, "203.0.113.10") {
		t.Fatalf("audit log missing blocked event/target host: %s", logs)
	}
	if !strings.Contains(logs, "proxy.example:8080") {
		t.Fatalf("audit log missing redacted proxy endpoint: %s", logs)
	}
	if strings.Contains(logs, "super-secret") {
		t.Fatalf("audit log leaked proxy password: %s", logs)
	}
}

func TestInitRemoteCDPRefusesProxyAuthBeforeProbe(t *testing.T) {
	cfg := &config.RuntimeConfig{
		AttachAllowHosts:   []string{"203.0.113.10"},
		AttachAllowSchemes: []string{"ws"},
		Proxy: config.BrowserProxyConfig{
			Server:   "http://proxy.example:8080",
			Username: "user",
			Password: "super-secret",
		},
	}

	var err error
	logs := captureSlog(t, func() {
		_, _, _, _, _, err = InitRemoteCDP(context.Background(), cfg, "ws://203.0.113.10:9222/devtools/browser/abc")
	})
	if err == nil {
		t.Fatal("expected remote CDP proxy auth forwarding to be refused")
	}
	if !strings.Contains(err.Error(), "security.attach.forwardProxyAuth=true") {
		t.Fatalf("error should mention explicit opt-in, got %v", err)
	}
	if !strings.Contains(logs, "remote_cdp.proxy_auth_blocked") || !strings.Contains(logs, "203.0.113.10") {
		t.Fatalf("audit log missing blocked event/target host: %s", logs)
	}
	if strings.Contains(logs, "super-secret") {
		t.Fatalf("audit log leaked proxy password: %s", logs)
	}
}

func TestInitRemoteCDPRejectsDisallowedAttachSchemeBeforeProbe(t *testing.T) {
	cfg := &config.RuntimeConfig{
		AttachAllowHosts:   []string{"*"},
		AttachAllowSchemes: []string{"ws"},
	}

	_, _, _, _, _, err := InitRemoteCDP(context.Background(), cfg, "http://203.0.113.10:9222")
	if err == nil {
		t.Fatal("expected disallowed attach scheme to be rejected")
	}
	if !strings.Contains(err.Error(), "scheme") || !strings.Contains(err.Error(), "not allowed") {
		t.Fatalf("error should mention disallowed scheme, got %v", err)
	}
}

func TestRemoteProxyAuthAllowsExplicitOptInAndAuditsForward(t *testing.T) {
	cfg := &config.RuntimeConfig{
		AttachForwardProxyAuth: true,
		Proxy: config.BrowserProxyConfig{
			Server:   "http://proxy.example:8080",
			Username: "user",
			Password: "super-secret",
		},
	}

	if err := requireRemoteProxyAuthOptIn("ws://203.0.113.10:9222/devtools/browser/abc", cfg); err != nil {
		t.Fatalf("requireRemoteProxyAuthOptIn returned %v, want nil", err)
	}

	logs := captureSlog(t, func() {
		auditRemoteProxyAuthForward("ws://203.0.113.10:9222/devtools/browser/abc", cfg)
	})
	if !strings.Contains(logs, "remote_cdp.proxy_auth_forwarded") || !strings.Contains(logs, "203.0.113.10") {
		t.Fatalf("audit log missing forwarded event/target host: %s", logs)
	}
	if !strings.Contains(logs, "proxy.example:8080") {
		t.Fatalf("audit log missing redacted proxy endpoint: %s", logs)
	}
	if strings.Contains(logs, "super-secret") {
		t.Fatalf("audit log leaked proxy password: %s", logs)
	}
}

func TestRemoteProxyAuthNoopWithoutCredentials(t *testing.T) {
	cfg := &config.RuntimeConfig{
		Proxy: config.BrowserProxyConfig{Server: "http://proxy.example:8080"},
	}
	logs := captureSlog(t, func() {
		if err := requireRemoteProxyAuthOptIn("ws://203.0.113.10:9222/devtools/browser/abc", cfg); err != nil {
			t.Fatalf("requireRemoteProxyAuthOptIn returned %v, want nil", err)
		}
		auditRemoteProxyAuthForward("ws://203.0.113.10:9222/devtools/browser/abc", cfg)
	})
	if logs != "" {
		t.Fatalf("unexpected audit log without proxy credentials: %s", logs)
	}
}

func captureSlog(t *testing.T, fn func()) string {
	t.Helper()
	var buf bytes.Buffer
	old := slog.Default()
	slog.SetDefault(slog.New(slog.NewJSONHandler(&buf, nil)))
	defer slog.SetDefault(old)
	fn()
	return buf.String()
}

// The CDP credential path asks "is there a proxy to authenticate to", which is a
// different question from "is anything set": a block holding credentials and no server
// is kept on disk and reported to the operator, but there is nothing to answer for it.
func TestProxyAuthNeedsAServerNotJustCredentials(t *testing.T) {
	credentialsOnly := config.BrowserProxyConfig{Username: "bob", Password: "hunter2"}
	if ProxyAuthEnabled(credentialsOnly) {
		t.Error("proxy auth is enabled with credentials and no server, so a Fetch listener runs for a proxy that does not exist")
	}

	completed := credentialsOnly
	completed.Server = "http://proxy.example:8080"
	if !ProxyAuthEnabled(completed) {
		t.Error("proxy auth is not enabled once the server is set, so credentials set before the server stay unused")
	}
}