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.
374 lines
13 KiB
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
|
|
}
|