You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/gateway/console/relay_test.go

374 lines
13 KiB
Go

package console
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/coder/websocket"
)
type fakeIntrospector struct {
revoke bool
calls atomic.Int32
}
func (f *fakeIntrospector) Inspect(_ context.Context, request IntrospectionRequest) (IntrospectionResult, error) {
call := f.calls.Add(1)
if call == 1 {
if !request.Consume || request.ConnectionID != "" {
return IntrospectionResult{}, errSessionRevoked
}
return IntrospectionResult{Active: true, ConnectionID: strings.Repeat("c", 32),
AgentID: "12", AgentTicket: strings.Repeat("a", 32),
AgentExpiresAt: time.Now().Add(time.Minute).UTC().Format(time.RFC3339)}, nil
}
if request.Consume || request.ConnectionID != strings.Repeat("c", 32) {
return IntrospectionResult{}, errSessionRevoked
}
return IntrospectionResult{Active: !f.revoke}, nil
}
type fakeConnector struct {
url string
client *http.Client
calls atomic.Int32
}
func (f *fakeConnector) OpenConsole(ctx context.Context, agentID, ticket, sessionID string) (*websocket.Conn, error) {
f.calls.Add(1)
if agentID != "12" || ticket != strings.Repeat("a", 32) ||
sessionID != strings.Repeat("c", 32) {
return nil, errSessionRevoked
}
conn, response, err := websocket.Dial(ctx, f.url, &websocket.DialOptions{
HTTPClient: f.client, CompressionMode: websocket.CompressionDisabled,
})
if response != nil && response.Body != nil {
_ = response.Body.Close()
}
return conn, err
}
func newAgentServer(t *testing.T) *httptest.Server {
return newAgentServerWithPingBehavior(t, nil, true)
}
func newObservedAgentServer(t *testing.T, pings *atomic.Int32) *httptest.Server {
return newAgentServerWithPingBehavior(t, pings, true)
}
func newAgentServerWithPingBehavior(t *testing.T, pings *atomic.Int32, respond bool) *httptest.Server {
t.Helper()
return httptest.NewTLSServer(http.HandlerFunc(func(response http.ResponseWriter, request *http.Request) {
connection, err := websocket.Accept(response, request, &websocket.AcceptOptions{
CompressionMode: websocket.CompressionDisabled,
OnPingReceived: func(context.Context, []byte) bool {
if pings != nil {
pings.Add(1)
}
return respond
},
})
if err != nil {
return
}
defer connection.CloseNow()
for {
messageType, body, err := connection.Read(request.Context())
if err != nil {
return
}
if err := connection.Write(request.Context(), messageType, body); err != nil {
return
}
}
}))
}
func TestRelayHeartbeatsBothIdleConsoleWebSocketsWithoutDataFrames(t *testing.T) {
var agentPings atomic.Int32
var browserPings atomic.Int32
agentServer := newObservedAgentServer(t, &agentPings)
defer agentServer.Close()
introspector := &fakeIntrospector{}
connector := &fakeConnector{url: "wss" + strings.TrimPrefix(agentServer.URL, "https"), client: agentServer.Client()}
relay, _ := NewRelay(introspector, connector)
relay.recheckEvery = time.Hour
relay.heartbeatEvery = 5 * time.Millisecond
relay.heartbeatTimeout = 100 * time.Millisecond
server := httptest.NewServer(relay)
defer server.Close()
connection := dialBrowserWithPingHandler(t, server.URL, strings.Repeat("h", 32),
func(context.Context, []byte) bool {
browserPings.Add(1)
return true
})
defer connection.CloseNow()
type readResult struct {
messageType websocket.MessageType
body []byte
err error
}
read := make(chan readResult, 1)
go func() {
messageType, body, readErr := connection.Read(context.Background())
read <- readResult{messageType: messageType, body: body, err: readErr}
}()
deadline := time.Now().Add(time.Second)
for (agentPings.Load() == 0 || browserPings.Load() == 0) && time.Now().Before(deadline) {
time.Sleep(time.Millisecond)
}
if agentPings.Load() == 0 || browserPings.Load() == 0 {
t.Fatalf("heartbeats not observed: agent=%d browser=%d", agentPings.Load(), browserPings.Load())
}
if err := connection.Write(t.Context(), websocket.MessageBinary, []byte("RFB-after-heartbeat")); err != nil {
t.Fatal(err)
}
select {
case result := <-read:
if result.err != nil || result.messageType != websocket.MessageBinary || string(result.body) != "RFB-after-heartbeat" {
t.Fatalf("post-heartbeat frame type=%v body=%q err=%v", result.messageType, result.body, result.err)
}
case <-time.After(time.Second):
t.Fatal("binary console data stalled after heartbeat")
}
}
func TestRelayClosesConsoleWhenBrowserDoesNotPong(t *testing.T) {
agentServer := newAgentServer(t)
defer agentServer.Close()
introspector := &fakeIntrospector{}
connector := &fakeConnector{url: "wss" + strings.TrimPrefix(agentServer.URL, "https"), client: agentServer.Client()}
relay, _ := NewRelay(introspector, connector)
relay.recheckEvery = time.Hour
relay.heartbeatEvery = 5 * time.Millisecond
relay.heartbeatTimeout = 20 * time.Millisecond
server := httptest.NewServer(relay)
defer server.Close()
connection := dialBrowserWithPingHandler(t, server.URL, strings.Repeat("i", 32),
func(context.Context, []byte) bool { return false })
defer connection.CloseNow()
readContext, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
if _, _, err := connection.Read(readContext); err == nil {
t.Fatal("console remained open after the browser stopped answering Ping")
}
}
func TestRelayClosesBrowserWhenAgentDoesNotPong(t *testing.T) {
agentServer := newAgentServerWithPingBehavior(t, nil, false)
defer agentServer.Close()
introspector := &fakeIntrospector{}
connector := &fakeConnector{url: "wss" + strings.TrimPrefix(agentServer.URL, "https"), client: agentServer.Client()}
relay, _ := NewRelay(introspector, connector)
relay.recheckEvery = time.Hour
relay.heartbeatEvery = 5 * time.Millisecond
relay.heartbeatTimeout = 20 * time.Millisecond
server := httptest.NewServer(relay)
defer server.Close()
connection := dialBrowser(t, server.URL, strings.Repeat("j", 32))
defer connection.CloseNow()
readContext, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
if _, _, err := connection.Read(readContext); err == nil {
t.Fatal("browser console remained open after the Agent stopped answering Ping")
}
}
func TestRelayForwardsOnlyBinaryAndConsumesTicketOnce(t *testing.T) {
agentServer := newAgentServer(t)
defer agentServer.Close()
introspector := &fakeIntrospector{}
connector := &fakeConnector{url: "wss" + strings.TrimPrefix(agentServer.URL, "https"), client: agentServer.Client()}
relay, _ := NewRelay(introspector, connector)
relay.recheckEvery = time.Hour
server := httptest.NewServer(relay)
defer server.Close()
connection := dialBrowser(t, server.URL, strings.Repeat("b", 32))
if err := connection.Write(t.Context(), websocket.MessageBinary, []byte("RFB-test")); err != nil {
t.Fatal(err)
}
messageType, body, err := connection.Read(t.Context())
if err != nil || messageType != websocket.MessageBinary || string(body) != "RFB-test" {
t.Fatalf("echo type=%v body=%q err=%v", messageType, body, err)
}
if introspector.calls.Load() != 1 {
t.Fatalf("initial ticket was consumed %d times", introspector.calls.Load())
}
if err := connection.Write(t.Context(), websocket.MessageText, []byte("forbidden")); err != nil {
t.Fatal(err)
}
readContext, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
if _, _, err := connection.Read(readContext); err == nil {
t.Fatal("text frame did not close relay")
}
}
func TestRelayDisconnectsWhenPeriodicIntrospectionRevokes(t *testing.T) {
agentServer := newAgentServer(t)
defer agentServer.Close()
introspector := &fakeIntrospector{revoke: true}
connector := &fakeConnector{url: "wss" + strings.TrimPrefix(agentServer.URL, "https"), client: agentServer.Client()}
relay, _ := NewRelay(introspector, connector)
relay.recheckEvery = 20 * time.Millisecond
server := httptest.NewServer(relay)
defer server.Close()
connection := dialBrowser(t, server.URL, strings.Repeat("e", 32))
readContext, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
if _, _, err := connection.Read(readContext); err == nil {
t.Fatal("revoked connection remained open")
}
if introspector.calls.Load() < 2 {
t.Fatal("periodic introspection was not called")
}
}
func TestRelayRejectsMissingOrCrossSiteOriginBeforeIntrospection(t *testing.T) {
introspector := &fakeIntrospector{}
relay, _ := NewRelay(introspector, &fakeConnector{})
request := httptest.NewRequest(http.MethodGet, "http://panel.example/engine-console", nil)
request.Host = "panel.example"
request.Header.Set("Origin", "https://evil.example")
request.Header.Set("X-Forwarded-Proto", "https")
request.Header.Set("Sec-WebSocket-Protocol", BrowserProtocolPrefix+strings.Repeat("b", 32))
response := httptest.NewRecorder()
relay.ServeHTTP(response, request)
if response.Code != http.StatusForbidden || introspector.calls.Load() != 0 {
t.Fatalf("cross-site status=%d introspection_calls=%d", response.Code, introspector.calls.Load())
}
}
func TestRelayRejectsNonWebSocketRequestBeforeConsumingTicket(t *testing.T) {
introspector := &fakeIntrospector{}
relay, _ := NewRelay(introspector, &fakeConnector{})
request := httptest.NewRequest(http.MethodGet, "http://panel.example/engine-console", nil)
request.Host = "panel.example"
request.Header.Set("Origin", "https://panel.example")
request.Header.Set("X-Forwarded-Proto", "https")
request.Header.Set("Sec-WebSocket-Protocol", BrowserProtocolPrefix+strings.Repeat("b", 32))
response := httptest.NewRecorder()
relay.ServeHTTP(response, request)
if response.Code != http.StatusBadRequest || introspector.calls.Load() != 0 {
t.Fatalf("ordinary HTTP status=%d introspection_calls=%d", response.Code, introspector.calls.Load())
}
}
func TestRelayDrainRejectsNewConsoleBeforeTicketConsumption(t *testing.T) {
introspector := &fakeIntrospector{}
relay, _ := NewRelay(introspector, &fakeConnector{})
relay.BeginDrain()
request := httptest.NewRequest(http.MethodGet,
"http://panel.example/engine-console", nil)
request.Host = "panel.example"
request.Header.Set("Origin", "http://panel.example")
request.Header.Set("X-Forwarded-Proto", "http")
request.Header.Set("Connection", "Upgrade")
request.Header.Set("Upgrade", "websocket")
request.Header.Set("Sec-WebSocket-Version", "13")
request.Header.Set("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==")
request.Header.Set("Sec-WebSocket-Protocol",
BrowserProtocolPrefix+strings.Repeat("b", 32))
response := httptest.NewRecorder()
relay.ServeHTTP(response, request)
if response.Code != http.StatusServiceUnavailable || introspector.calls.Load() != 0 {
t.Fatalf("draining relay status=%d introspection_calls=%d",
response.Code, introspector.calls.Load())
}
if err := relay.Wait(t.Context()); err != nil {
t.Fatal(err)
}
}
func TestRelayCloseCancelsActiveHijackedConsole(t *testing.T) {
agentServer := newAgentServer(t)
defer agentServer.Close()
relay, _ := NewRelay(&fakeIntrospector{}, &fakeConnector{
url: "wss" + strings.TrimPrefix(agentServer.URL, "https"),
client: agentServer.Client(),
})
relay.recheckEvery = time.Hour
server := httptest.NewServer(relay)
defer server.Close()
connection := dialBrowser(t, server.URL, strings.Repeat("f", 32))
defer connection.CloseNow()
relay.BeginDrain()
short, cancelShort := context.WithTimeout(t.Context(), 20*time.Millisecond)
if err := relay.Wait(short); !errors.Is(err, context.DeadlineExceeded) {
cancelShort()
t.Fatalf("drain did not wait for active console: %v", err)
}
cancelShort()
relay.Close()
wait, cancelWait := context.WithTimeout(t.Context(), time.Second)
defer cancelWait()
if err := relay.Wait(wait); err != nil {
t.Fatalf("active console did not close: %v", err)
}
}
func TestRelayRequiresReverseConnector(t *testing.T) {
if _, err := NewRelay(&fakeIntrospector{}, nil); err == nil {
t.Fatal("relay accepted a missing reverse console connector")
}
}
func TestValidateInitialResultRequiresLiveShortLivedAgentTicket(t *testing.T) {
now := time.Date(2026, time.October, 16, 12, 0, 0, 0, time.UTC)
valid := IntrospectionResult{
Active: true, ConnectionID: strings.Repeat("c", 32), AgentID: "12",
AgentTicket: strings.Repeat("a", 32), AgentExpiresAt: now.Add(time.Minute).Format(time.RFC3339),
}
if err := validateInitialResult(valid, now); err != nil {
t.Fatalf("valid introspection result rejected: %v", err)
}
valid.AgentExpiresAt = now.Format(time.RFC3339)
if err := validateInitialResult(valid, now); err == nil {
t.Fatal("expired Agent ticket was accepted")
}
valid.AgentExpiresAt = now.Add(2*time.Minute + time.Second).Format(time.RFC3339)
if err := validateInitialResult(valid, now); err == nil {
t.Fatal("overlong Agent ticket was accepted")
}
}
func dialBrowser(t *testing.T, serverURL, ticket string) *websocket.Conn {
return dialBrowserWithPingHandler(t, serverURL, ticket, nil)
}
func dialBrowserWithPingHandler(
t *testing.T,
serverURL string,
ticket string,
onPingReceived func(context.Context, []byte) bool,
) *websocket.Conn {
t.Helper()
websocketURL := "ws" + strings.TrimPrefix(serverURL, "http") + "/engine-console"
host := strings.TrimPrefix(serverURL, "http://")
connection, response, err := websocket.Dial(t.Context(), websocketURL, &websocket.DialOptions{
Subprotocols: []string{BrowserProtocolPrefix + ticket},
HTTPHeader: http.Header{"Origin": []string{"http://" + host}, "X-Forwarded-Proto": []string{"http"}},
OnPingReceived: onPingReceived,
})
if response != nil && response.Body != nil {
_ = response.Body.Close()
}
if err != nil {
t.Fatalf("dial browser relay: %v", err)
}
return connection
}