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.

14.3 KB
Raw Blame
package notifications

import (
	"bytes"
	"errors"
	"net/url"
	"strings"
	"testing"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func TestRedactWebhookURLSecrets(t *testing.T) {
	tests := map[string]struct {
		input string
		want  string
	}{
		"malformed query name":             {input: "https://example.test/hook?%zz=secret", want: invalidWebhookURLDiagnostic},
		"encoded lookalike":                {input: "https://example.test/hook?extra_%74oken=visible&channel=ops#fragment", want: "https://example.test/hook?extra_%74oken=visible&channel=ops#fragment"},
		"discord":                          {input: "https://discord.com/api/webhooks/123/discord-secret", want: "https://discord.com/api/webhooks/REDACTED"},
		"discord versioned":                {input: "https://discord.com/api/v10/webhooks/123/discord-secret", want: "https://discord.com/api/v10/webhooks/REDACTED"},
		"discord legacy":                   {input: "https://discordapp.com/api/webhooks/123/discord-secret", want: "https://discordapp.com/api/webhooks/REDACTED"},
		"discord encoded":                  {input: "https://user:[email protected]:443/api/webhooks/123/discord%2Dsecret", want: "https://[email protected]:443/api/webhooks/REDACTED"},
		"discord query":                    {input: "https://discord.com/api/webhooks/123/discord-secret?wait=true&token=query-secret", want: "https://discord.com/api/webhooks/REDACTED?wait=true&token=REDACTED"},
		"discord lookalike":                {input: "https://discord.com.example.org/api/webhooks/status", want: "https://discord.com.example.org/api/webhooks/status"},
		"discord unrelated":                {input: "https://discord.com/api/status", want: "https://discord.com/api/status"},
		"slack":                            {input: "https://hooks.slack.com/services/T-test/B-test/slack-secret", want: "https://hooks.slack.com/services/REDACTED"},
		"gov slack":                        {input: "https://hooks.slack-gov.com/services/T-test/B-test/slack-secret?token=query-secret&channel=ops", want: "https://hooks.slack-gov.com/services/REDACTED?token=REDACTED&channel=ops"},
		"slack encoded path and authority": {input: "https://user:[email protected]:443/serv%69ces/T-test/B-test/slack%2Dsecret", want: "https://[email protected]:443/services/REDACTED"},
		"slack legacy path":                {input: "https://hooks.slack.com/T-test/B-test/slack-secret", want: "https://hooks.slack.com/REDACTED"},
		"unrelated services path":          {input: "https://example.com/services/status", want: "https://example.com/services/status"},
		"slack lookalike":                  {input: "https://hooks.slack.com.example.org/services/status", want: "https://hooks.slack.com.example.org/services/status"},
		"basic auth": {
			input: "https://hook-user:[email protected]/hook",
			want:  "https://[email protected]/hook",
		},
		"username only": {
			input: "https://[email protected]/hook",
			want:  "https://[email protected]/hook",
		},
		"encoded credentials with other secrets": {
			input: "https://hook%40user:p%40s[email protected]/bot123:secret/send?token=query-secret&channel=ops",
			want:  "https://[email protected]/botREDACTED/send?token=REDACTED&channel=ops",
		},
		"malformed credential URL": {
			input: "https://hook-user:[email protected]/%zz",
			want:  "[invalid webhook URL]",
		},
		"at sign outside authority": {
			input: "https://example.com/hooks/@ops?channel=team@ops",
			want:  "https://example.com/hooks/@ops?channel=team@ops",
		},
		"gotify token": {
			input: "https://gotify.example/message?token=gotify-secret",
			want:  "https://gotify.example/message?token=REDACTED",
		},
		"telegram escaped prefix":           {input: "https://api.telegram.org/%62ot123:telegram-secret/sendMessage", want: "https://api.telegram.org/botREDACTED/sendMessage"},
		"telegram escaped token":            {input: "https://api.telegram.org/bot123:telegram%2Dsecret/sendMessage", want: "https://api.telegram.org/botREDACTED/sendMessage"},
		"telegram local escaped prefix":     {input: "http://localhost:8081/%62ot123:telegram-secret/sendMessage", want: "http://localhost:8081/botREDACTED/sendMessage"},
		"telegram no method with URL query": {input: "https://api.telegram.org/bot123:telegram-secret?next=https://example.org/status", want: "https://api.telegram.org/botREDACTED?next=https://example.org/status"},
		"telegram fragment":                 {input: "https://api.telegram.org/bot123:telegram-secret#diagnostic", want: "https://api.telegram.org/botREDACTED#diagnostic"},
		"bot hostname is not a path":        {input: "https://bot.example.org/hook?channel=ops", want: "https://bot.example.org/hook?channel=ops"},
		"bot query is not a path":           {input: "https://example.org/hook?next=https://bot.example.org/status", want: "https://example.org/hook?next=https://bot.example.org/status"},
		"telegram path and query": {
			input: "https://api.telegram.org/bot123:secret/send?token=query-secret",
			want:  "https://api.telegram.org/botREDACTED/send?token=REDACTED",
		},
		"unrelated parameters": {
			input: "https://example.com/hook?extra_token=visible&channel=ops",
			want:  "https://example.com/hook?extra_token=visible&channel=ops",
		},
	}

	for name, test := range tests {
		t.Run(name, func(t *testing.T) {
			if got := RedactWebhookURLSecrets(test.input); got != test.want {
				t.Fatalf("RedactWebhookURLSecrets() = %q, want %q", got, test.want)
			}
		})
	}
}

// Diagnostic masking is deliberately conservative even though a destination
// may treat query names as case-sensitive. It must not change the request URL.
func TestRedactWebhookMixedCaseQuerySecrets(t *testing.T) {
	for _, key := range []string{"TOKEN", "ApiKey", "Api_Key", "KEY", "Secret", "PassWord", "%54oKeN"} {
		t.Run(key, func(t *testing.T) {
			raw := "https://example.test/hook?" + key + "=synthetic-secret&token=second-secret&extra_TOKEN=visible&channel=ops"
			want := "https://example.test/hook?" + key + "=REDACTED&token=REDACTED&extra_TOKEN=visible&channel=ops"
			if got := RedactWebhookURLSecrets(raw); got != want {
				t.Errorf("URL = %q, want %q", got, want)
			}
			if got := RedactWebhookDiagnosticSecrets("post " + raw + " failed"); got != "post "+want+" failed" {
				t.Errorf("diagnostic = %q", got)
			}
			cause := errors.New("connection refused")
			original := &url.Error{Op: "Post", URL: raw, Err: cause}
			redacted := redactWebhookTransportError(original)
			if strings.Contains(redacted.Error(), "synthetic-secret") || strings.Contains(redacted.Error(), "second-secret") {
				t.Errorf("transport diagnostic exposed synthetic credential: %v", redacted)
			}
			if original.URL != raw || !errors.Is(redacted, cause) {
				t.Fatal("redaction changed request URL or error identity")
			}
		})
	}
}

func TestRedactWebhookDiagnosticSecrets(t *testing.T) {
	tests := map[string]struct {
		input string
		want  string
	}{
		"embedded query credential": {
			input: "post https://hooks.example.test/notify?token=supersecret returned 401",
			want:  "post https://hooks.example.test/notify?token=REDACTED returned 401",
		},
		"embedded userinfo": {
			input: "request to https://hook-user:[email protected]/hook failed",
			want:  "request to https://[email protected]/hook failed",
		},
		"plain diagnostic": {
			input: "connection refused",
			want:  "connection refused",
		},
		"malformed embedded URL": {
			input: "post https://hook-user:[email protected]/%zz failed",
			want:  invalidWebhookURLDiagnostic,
		},
		"apprise CLI prose": {
			input: `process queued apprise notification "apprise-1" (alert): apprise CLI send failed: execute apprise CLI: executable file not found in PATH`,
			want:  `process queued apprise notification "apprise-1" (alert): apprise CLI send failed: execute apprise CLI: executable file not found in PATH`,
		},
		"smtp prose": {
			input: `process queued email notification "email-1" (alert): smtp: 535 5.7.8 authentication failed`,
			want:  `process queued email notification "email-1" (alert): smtp: 535 5.7.8 authentication failed`,
		},
		"schemeless query credential in prose": {
			input: "send failed: hooks.example.test/notify?token=supersecret refused",
			want:  "send failed: hooks.example.test/notify?token=REDACTED refused",
		},
		"schemeless bot path in prose": {
			input: "send failed: api.telegram.org/bot123:telegram-secret/sendMessage refused",
			want:  "send failed: api.telegram.org/botREDACTED/sendMessage refused",
		},
		"malformed schemeless word": {
			input: "send failed: hooks.example.test/notify?%zz=secret refused",
			want:  invalidWebhookURLDiagnostic,
		},
	}

	for name, test := range tests {
		t.Run(name, func(t *testing.T) {
			if got := RedactWebhookDiagnosticSecrets(test.input); got != test.want {
				t.Fatalf("RedactWebhookDiagnosticSecrets() = %q, want %q", got, test.want)
			}
		})
	}
}

func TestRedactWebhookTransportErrorPreservesBehaviorWithoutToken(t *testing.T) {
	cause := errors.New("connection refused")
	original := &url.Error{
		Op:  "Post",
		URL: "https://hook-user:[email protected]/message?token=gotify-secret",
		Err: cause,
	}

	redacted := redactWebhookTransportError(original)
	if strings.Contains(redacted.Error(), "gotify-secret") || strings.Contains(redacted.Error(), "hook-password") || strings.Contains(redacted.Error(), "hook-user") {
		t.Fatalf("redacted transport error exposed token: %v", redacted)
	}
	if !strings.Contains(redacted.Error(), "token=REDACTED") {
		t.Fatalf("redacted transport error omitted diagnostic URL shape: %v", redacted)
	}
	if original.URL != "https://hook-user:[email protected]/message?token=gotify-secret" {
		t.Fatal("redaction mutated the original transport error")
	}
	if !errors.Is(redacted, cause) {
		t.Fatal("redacted transport error no longer unwraps to its original cause")
	}
}

// TestWebhookRateLimitLogsRedactURLSecrets captures the actual log output of
// the rate-limit drop paths. Both of these logged the raw webhook URL until
// this test existed: the redaction sweep converted five call sites but missed
// checkWebhookRateLimit and the enhanced sender, and no test asserted log
// content, so a token in the URL still reached the logs on the one event most
// likely to fire repeatedly.
func TestWebhookRateLimitLogsRedactURLSecrets(t *testing.T) {
	const secret = "gotify-secret"
	webhookURL := "https://hook-user:[email protected]/message?token=" + secret

	var captured bytes.Buffer
	original := log.Logger
	log.Logger = zerolog.New(&captured)
	t.Cleanup(func() { log.Logger = original })

	nm := &NotificationManager{
		webhookRateLimits: make(map[string]*webhookRateLimit),
	}

	// Exhaust the window so the drop path logs.
	for range WebhookRateLimitMax + 2 {
		nm.checkWebhookRateLimit(webhookURL)
	}

	out := captured.String()
	if !strings.Contains(out, "rate limit exceeded") {
		t.Fatalf("expected the rate-limit drop to be logged, got %q", out)
	}
	if strings.Contains(out, secret) || strings.Contains(out, "hook-password") || strings.Contains(out, "hook-user") {
		t.Fatalf("webhook token leaked into logs: %q", out)
	}
	if !strings.Contains(out, "token=REDACTED") {
		t.Fatalf("expected redacted url in logs, got %q", out)
	}
}

func TestSlackWebhookDiagnosticsRedactPath(t *testing.T) {
	const webhookURL = "https://hooks.slack.com/services/T-test/B-test/slack-secret"
	cause := errors.New("connection refused")
	original := &url.Error{Op: "Post", URL: webhookURL, Err: cause}
	redacted := redactWebhookTransportError(original)
	if strings.Contains(redacted.Error(), "slack-secret") || !strings.Contains(redacted.Error(), "/services/REDACTED") {
		t.Fatalf("unsafe transport diagnostic: %v", redacted)
	}
	if original.URL != webhookURL || !errors.Is(redacted, cause) {
		t.Fatal("transport error identity or cause changed")
	}
	var captured bytes.Buffer
	logger := log.Logger
	log.Logger = zerolog.New(&captured)
	t.Cleanup(func() { log.Logger = logger })
	nm := &NotificationManager{webhookRateLimits: make(map[string]*webhookRateLimit)}
	for range WebhookRateLimitMax + 2 {
		nm.checkWebhookRateLimit(webhookURL)
	}
	out := captured.String()
	if !strings.Contains(out, "rate limit exceeded") || !strings.Contains(out, "/services/REDACTED") || strings.Contains(out, "slack-secret") {
		t.Fatalf("unsafe rate-limit diagnostic: %s", out)
	}
}
func TestDiscordWebhookDiagnosticsRedactPath(t *testing.T) {
	const webhookURL = "https://discord.com/api/webhooks/123/discord-secret"
	cause := errors.New("connection refused")
	original := &url.Error{Op: "Post", URL: webhookURL, Err: cause}
	redacted := redactWebhookTransportError(original)
	if strings.Contains(redacted.Error(), "discord-secret") || !strings.Contains(redacted.Error(), "/api/webhooks/REDACTED") {
		t.Fatalf("unsafe transport diagnostic: %v", redacted)
	}
	if original.URL != webhookURL || !errors.Is(redacted, cause) {
		t.Fatal("transport error identity or cause changed")
	}
	var captured bytes.Buffer
	logger := log.Logger
	log.Logger = zerolog.New(&captured)
	t.Cleanup(func() { log.Logger = logger })
	nm := &NotificationManager{webhookRateLimits: make(map[string]*webhookRateLimit)}
	for range WebhookRateLimitMax + 2 {
		nm.checkWebhookRateLimit(webhookURL)
	}
	out := captured.String()
	if !strings.Contains(out, "rate limit exceeded") || !strings.Contains(out, "/api/webhooks/REDACTED") || strings.Contains(out, "discord-secret") {
		t.Fatalf("unsafe rate-limit diagnostic: %s", out)
	}
}

func TestTelegramWebhookDiagnosticsRedactPath(t *testing.T) {
	const webhookURL = "https://api.telegram.org/%62ot123:telegram-secret/sendMessage"
	cause := errors.New("connection refused")
	original := &url.Error{Op: "Post", URL: webhookURL, Err: cause}
	redacted := redactWebhookTransportError(original)
	if strings.Contains(redacted.Error(), "telegram-secret") || !strings.Contains(redacted.Error(), "/botREDACTED/sendMessage") {
		t.Fatalf("unsafe transport diagnostic: %v", redacted)
	}
	if original.URL != webhookURL || !errors.Is(redacted, cause) {
		t.Fatal("transport error identity or cause changed")
	}
	var captured bytes.Buffer
	logger := log.Logger
	log.Logger = zerolog.New(&captured)
	t.Cleanup(func() { log.Logger = logger })
	nm := &NotificationManager{webhookRateLimits: make(map[string]*webhookRateLimit)}
	for range WebhookRateLimitMax + 2 {
		nm.checkWebhookRateLimit(webhookURL)
	}
	out := captured.String()
	if !strings.Contains(out, "rate limit exceeded") || !strings.Contains(out, "/botREDACTED/sendMessage") || strings.Contains(out, "telegram-secret") {
		t.Fatalf("unsafe rate-limit diagnostic: %s", out)
	}
}