From 85d0990e1269c93a38a2619a7c26dd01435db112 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sat, 26 Sep 2026 09:24:12 -0600 Subject: [PATCH 1/3] feat(ssh): add managed transport SSH dialer --- cmd/machine/ssh.go | 4 +- cmd/workspace/ssh.go | 4 +- pkg/client/client.go | 4 +- pkg/devcontainer/sshtunnel/sshtunnel.go | 2 +- pkg/ssh/helper_test.go | 2 +- pkg/ssh/managed_client.go | 351 ++++++++++++++++++++++++ pkg/ssh/managed_client_test.go | 300 ++++++++++++++++++++ pkg/tunnel/browser.go | 2 +- pkg/tunnel/container.go | 6 +- pkg/tunnel/direct.go | 6 +- 10 files changed, 669 insertions(+), 12 deletions(-) create mode 100644 pkg/ssh/managed_client.go create mode 100644 pkg/ssh/managed_client_test.go diff --git a/cmd/machine/ssh.go b/cmd/machine/ssh.go index acaf349621..27bb195239 100644 --- a/cmd/machine/ssh.go +++ b/cmd/machine/ssh.go @@ -210,7 +210,9 @@ func StartSSHSession(ctx context.Context, options StartSSHSessionOptions) error TransportSide: transport.SideProvider, Metadata: transport.LogMetadata{Mode: "machine", TransportImpl: "callback"}, Handler: func(ctx context.Context) error { - sshClient, err := devssh.ClientFromConn(conn, options.User, nil) + sshClient, err := devssh.ClientFromManagedConn(ctx, conn, devssh.ManagedClientOptions{ + User: options.User, + }) if err != nil { return err } diff --git a/cmd/workspace/ssh.go b/cmd/workspace/ssh.go index d350ef4326..9302f82746 100644 --- a/cmd/workspace/ssh.go +++ b/cmd/workspace/ssh.go @@ -370,7 +370,9 @@ func (cmd *SSHCmd) startProxyTunnel( Workspace: client.Workspace(), TransportImpl: "callback", }, Handler: func(ctx context.Context) error { - containerClient, err := devssh.ClientFromConn(conn, cmd.User, nil) + containerClient, err := devssh.ClientFromManagedConn( + ctx, conn, devssh.ManagedClientOptions{User: cmd.User}, + ) if err != nil { return err } diff --git a/pkg/client/client.go b/pkg/client/client.go index e9c52681be..fb6363ebd4 100644 --- a/pkg/client/client.go +++ b/pkg/client/client.go @@ -79,8 +79,8 @@ type ProxyClient interface { // Ssh starts an ssh tunnel to the workspace container Ssh(ctx context.Context, options SshOptions) error - // OpenSSHTransport starts an SSH transport whose stdin/stdout carry the - // persistent SSH protocol. + // OpenSSHTransport starts a managed SSH transport whose peer may still be + // bootstrapping when the connection is returned. Use the managed SSH dialer. OpenSSHTransport( ctx context.Context, options SSHTransportOptions, diff --git a/pkg/devcontainer/sshtunnel/sshtunnel.go b/pkg/devcontainer/sshtunnel/sshtunnel.go index 0d467e9565..8398657c4e 100644 --- a/pkg/devcontainer/sshtunnel/sshtunnel.go +++ b/pkg/devcontainer/sshtunnel/sshtunnel.go @@ -126,7 +126,7 @@ func runSSHTunnel(ctx context.Context, p sshTunnelParams) (*config2.Result, erro defer func() { log.Debugf("tunnel: setup complete elapsed=%s", time.Since(start)) }() log.Debug("creating SSH client") - sshClient, err := devssh.ClientFromConn(p.conn, "", nil) + sshClient, err := devssh.ClientFromManagedConn(ctx, p.conn, devssh.ManagedClientOptions{}) if err != nil { return nil, fmt.Errorf("failed to create SSH client: %w", err) } diff --git a/pkg/ssh/helper_test.go b/pkg/ssh/helper_test.go index 2fa6867bc3..ba1ee38a67 100644 --- a/pkg/ssh/helper_test.go +++ b/pkg/ssh/helper_test.go @@ -191,7 +191,7 @@ func TestClientFromConn_SuccessfulHandshake(t *testing.T) { clientEnd, err := net.Dial("tcp", listener.Addr().String()) require.NoError(t, err) conn := &deadlineRecorder{Conn: clientEnd} - client, err := clientFromConn(conn, "test", nil, 5*time.Second) + client, err := ClientFromConn(conn, "test", nil) require.NoError(t, err) require.NotNil(t, client) diff --git a/pkg/ssh/managed_client.go b/pkg/ssh/managed_client.go new file mode 100644 index 0000000000..46a3c7cc5c --- /dev/null +++ b/pkg/ssh/managed_client.go @@ -0,0 +1,351 @@ +package ssh + +import ( + "context" + "errors" + "io" + "net" + "sync" + "sync/atomic" + "time" + + "github.com/devsy-org/devsy/pkg/transport" + xssh "golang.org/x/crypto/ssh" +) + +// ManagedClientOptions configures SSH over a transport whose peer may still be starting. +// Zero timeout values use the standard SSH handshake limits. +type ManagedClientOptions struct { + User string + KeyBytes []byte + HandshakeIdleTimeout time.Duration + HandshakeMaxTimeout time.Duration +} + +type managedHandshakeConn struct { + net.Conn + tracking atomic.Bool + peerStarted atomic.Bool + peerOnce sync.Once + peerReady chan struct{} + activity atomic.Pointer[time.Time] +} + +type managedSSHPhase uint8 + +const ( + managedSSHBootstrap managedSSHPhase = iota + managedSSHHandshake +) + +func (c *managedHandshakeConn) Read(p []byte) (int, error) { + n, err := c.Conn.Read(p) + if n > 0 { + c.recordActivity() + c.peerOnce.Do(func() { + c.peerStarted.Store(true) + close(c.peerReady) + }) + } + return n, err +} + +func (c *managedHandshakeConn) Write(p []byte) (int, error) { + n, err := c.Conn.Write(p) + if n > 0 && c.peerStarted.Load() { + c.recordActivity() + } + return n, err +} + +func (c *managedHandshakeConn) recordActivity() { + if c.tracking.Load() { + now := time.Now() + c.activity.Store(&now) + } +} + +// ClientFromManagedConn starts the SSH client immediately, allowing its local +// identification write during bootstrap. Handshake limits begin only when the +// managed peer first sends protocol bytes. +func ClientFromManagedConn( + ctx context.Context, + conn transport.ManagedConn, + opts ManagedClientOptions, +) (*xssh.Client, error) { + if conn == nil { + return nil, errors.New("managed connection is required") + } + if ctx == nil { + return nil, errors.New("context is required") + } + if err := ctx.Err(); err != nil { + _ = conn.Close() + return nil, err + } + config, err := ConfigFromKeyBytes(opts.KeyBytes) + if err != nil { + _ = conn.Close() + return nil, err + } + config.User = opts.User + + idle := opts.HandshakeIdleTimeout + if idle <= 0 { + idle = HandshakeIdleTimeout + } + maxTimeout := opts.HandshakeMaxTimeout + if maxTimeout <= 0 { + maxTimeout = handshakeMaxTimeout + } + + dialer := newManagedSSHClientDialer(managedSSHClientOptions{ + ctx: ctx, conn: conn, config: config, idle: idle, maxTimeout: maxTimeout, + }) + return dialer.run() +} + +type managedSSHClientOptions struct { + ctx context.Context + conn transport.ManagedConn + config *xssh.ClientConfig + idle time.Duration + maxTimeout time.Duration +} + +type managedSSHClientDialer struct { + ctx context.Context + conn transport.ManagedConn + tracked *managedHandshakeConn + result chan handshakeResult + transportDone chan error + phase managedSSHPhase + idle time.Duration + maxTimeout time.Duration + ticker *time.Ticker + maxTimer *time.Timer + peerReady <-chan struct{} + ticks <-chan time.Time + maximum <-chan time.Time +} + +func newManagedSSHClientDialer(opts managedSSHClientOptions) *managedSSHClientDialer { + ctx, conn, config := opts.ctx, opts.conn, opts.config + tracked := &managedHandshakeConn{Conn: conn, peerReady: make(chan struct{})} + tracked.tracking.Store(true) + dialer := &managedSSHClientDialer{ + ctx: ctx, conn: conn, tracked: tracked, result: make(chan handshakeResult, 1), + transportDone: make(chan error, 1), phase: managedSSHBootstrap, + idle: opts.idle, maxTimeout: opts.maxTimeout, peerReady: tracked.peerReady, + } + go func() { + c, chans, reqs, err := xssh.NewClientConn(tracked, "stdio", config) + dialer.result <- handshakeResult{c: c, chans: chans, reqs: reqs, err: err} + }() + go func() { dialer.transportDone <- conn.Wait() }() + return dialer +} + +func (d *managedSSHClientDialer) run() (*xssh.Client, error) { + defer d.stop() + for { + client, err, done := d.waitEvent() + if done { + return client, err + } + } +} + +func (d *managedSSHClientDialer) waitEvent() (*xssh.Client, error, bool) { + select { + case <-d.peerReady: + d.startHandshakeTimers() + return nil, nil, false + case res := <-d.result: + client, err := d.finishHandshake(res) + return client, err, true + case transportErr := <-d.transportDone: + client, err := d.finishTransport(transportErr) + return client, err, true + case <-d.ctx.Done(): + return nil, d.finishCancellation(), true + case <-d.ticks: + return d.checkIdleTimeout() + case <-d.maximum: + client, err := d.finishTimeout(d.maxTimeout) + return client, err, true + } +} + +func (d *managedSSHClientDialer) startHandshakeTimers() { + d.peerReady = nil + d.phase = managedSSHHandshake + tickInterval := d.idle / 4 + if tickInterval <= 0 { + tickInterval = d.idle + } + d.ticker = time.NewTicker(tickInterval) + d.ticks = d.ticker.C + d.maxTimer = time.NewTimer(d.maxTimeout) + d.maximum = d.maxTimer.C +} + +func (d *managedSSHClientDialer) stop() { + d.tracked.tracking.Store(false) + if d.ticker != nil { + d.ticker.Stop() + } + if d.maxTimer != nil { + d.maxTimer.Stop() + } +} + +func (d *managedSSHClientDialer) finishHandshake(res handshakeResult) (*xssh.Client, error) { + if res.err == nil { + return d.newClient(res) + } + if !d.tracked.peerStarted.Load() || isManagedStreamEnd(res.err) { + // A read reset before peer output can race the callback's terminal + // bootstrap error. The managed result is authoritative in this phase. + res.err = managedTerminalError(d.ctx, d.transportDone) + } + d.closeConn() + return nil, res.err +} + +func (d *managedSSHClientDialer) finishTransport(transportErr error) (*xssh.Client, error) { + if d.tracked.peerStarted.Load() { + d.phase = managedSSHHandshake + } + // A completed launcher cannot produce more protocol bytes. Check a + // completed handshake first so a concrete SSH error is preserved. + select { + case res := <-d.result: + if res.err == nil { + return d.newClient(res) + } + if d.phase == managedSSHHandshake && !isManagedStreamEnd(res.err) { + d.closeConn() + return nil, res.err + } + default: + } + d.closeConn() + if transportErr == nil { + return nil, io.EOF + } + return nil, transportErr +} + +func (d *managedSSHClientDialer) finishCancellation() error { + if err := d.pendingError(); err != nil { + d.closeConn() + return err + } + d.closeConn() + return d.ctx.Err() +} + +func (d *managedSSHClientDialer) pendingError() error { + if err := d.pendingHandshakeError(); err != nil { + return err + } + return d.pendingTransportError() +} + +func (d *managedSSHClientDialer) pendingHandshakeError() error { + if d.phase != managedSSHHandshake { + return nil + } + select { + case res := <-d.result: + if res.err != nil && !isManagedStreamEnd(res.err) { + return res.err + } + default: + } + return nil +} + +func (d *managedSSHClientDialer) pendingTransportError() error { + select { + case transportErr := <-d.transportDone: + if transportErr != nil && !errors.Is(transportErr, d.ctx.Err()) { + return transportErr + } + default: + } + return nil +} + +func (d *managedSSHClientDialer) checkIdleTimeout() (*xssh.Client, error, bool) { + activity := d.tracked.activity.Load() + if activity == nil || time.Since(*activity) <= d.idle { + return nil, nil, false + } + client, err := d.finishTimeout(d.idle) + return client, err, true +} + +func (d *managedSSHClientDialer) finishTimeout(timeout time.Duration) (*xssh.Client, error) { + if err := d.ctx.Err(); err != nil { + d.closeConn() + return nil, err + } + select { + case res := <-d.result: + if res.err == nil { + return d.newClient(res) + } + if isManagedStreamEnd(res.err) { + res.err = managedTerminalError(d.ctx, d.transportDone) + } + d.closeConn() + return nil, res.err + case transportErr := <-d.transportDone: + d.closeConn() + if transportErr != nil { + return nil, transportErr + } + return nil, io.EOF + default: + } + d.closeConn() + return nil, &HandshakeTimeoutError{idle: timeout} +} + +func (d *managedSSHClientDialer) newClient(res handshakeResult) (*xssh.Client, error) { + if err := d.ctx.Err(); err != nil { + d.closeConn() + return nil, err + } + return xssh.NewClient(res.c, res.chans, handleKeepAliveRequests(res.reqs)), nil +} + +func (d *managedSSHClientDialer) closeConn() { + _ = d.conn.Close() +} + +func managedTerminalError(ctx context.Context, transportDone <-chan error) error { + select { + case err := <-transportDone: + if err != nil { + return err + } + return io.EOF + case <-ctx.Done(): + select { + case err := <-transportDone: + if err != nil && !errors.Is(err, ctx.Err()) { + return err + } + default: + } + return ctx.Err() + } +} + +func isManagedStreamEnd(err error) bool { + return errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) || + errors.Is(err, io.ErrClosedPipe) || errors.Is(err, net.ErrClosed) +} diff --git a/pkg/ssh/managed_client_test.go b/pkg/ssh/managed_client_test.go new file mode 100644 index 0000000000..78cb90ef2e --- /dev/null +++ b/pkg/ssh/managed_client_test.go @@ -0,0 +1,300 @@ +package ssh + +import ( + "bufio" + "context" + "crypto/ecdsa" + "crypto/elliptic" + "crypto/rand" + "errors" + "io" + "net" + "os" + "path/filepath" + "strings" + "sync" + "syscall" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + xssh "golang.org/x/crypto/ssh" +) + +func TestClientFromManagedConnAllowsDelayedBootstrap(t *testing.T) { + started := make(chan struct{}) + release := make(chan struct{}) + serverConfig := testServerConfig(t) + conn := openManagedTestConn(t, func(ctx context.Context, peer net.Conn) error { + close(started) + select { + case <-release: + case <-ctx.Done(): + return ctx.Err() + } + return serveTestSSH(ctx, peer, serverConfig) + }) + defer func() { _ = conn.Close() }() + + ctx, cancel := context.WithCancel(t.Context()) + defer cancel() + dialDone := make(chan struct { + client *xssh.Client + err error + }, 1) + go func() { + client, err := ClientFromManagedConn(ctx, conn, ManagedClientOptions{ + HandshakeIdleTimeout: 20 * time.Millisecond, + HandshakeMaxTimeout: time.Second, + }) + dialDone <- struct { + client *xssh.Client + err error + }{client: client, err: err} + }() + + <-started + select { + case result := <-dialDone: + if result.client != nil { + _ = result.client.Close() + } + t.Fatalf("managed dial ended during bootstrap: %v", result.err) + case <-time.After(100 * time.Millisecond): + } + close(release) + + select { + case result := <-dialDone: + require.NoError(t, result.err) + require.NotNil(t, result.client) + _ = result.client.Close() + case <-time.After(3 * time.Second): + t.Fatal("managed SSH handshake did not complete") + } +} + +func TestClientFromManagedConnReturnsBootstrapError(t *testing.T) { + wantErr := errors.New("agent injection failed") + conn := &resetOnStreamEndManagedConn{ + testManagedConn: openManagedTestConn(t, func(context.Context, net.Conn) error { + return wantErr + }), + } + defer func() { _ = conn.Close() }() + + _, err := ClientFromManagedConn(context.Background(), conn, ManagedClientOptions{ + HandshakeIdleTimeout: 20 * time.Millisecond, + }) + + require.ErrorIs(t, err, wantErr) + var timeoutErr *HandshakeTimeoutError + assert.NotErrorAs(t, err, &timeoutErr) +} + +type resetOnStreamEndManagedConn struct{ *testManagedConn } + +func (c *resetOnStreamEndManagedConn) Read(p []byte) (int, error) { + n, err := c.testManagedConn.Read(p) + if isManagedStreamEnd(err) { + return n, &net.OpError{Op: "read", Net: "tcp", Err: syscall.ECONNRESET} + } + return n, err +} + +func TestClientFromManagedConnTimesOutAfterPeerStartsHandshake(t *testing.T) { + conn := openManagedTestConn(t, func(ctx context.Context, peer net.Conn) error { + if _, err := readSSHIdentification(peer); err != nil { + return err + } + if _, err := io.WriteString(peer, "SSH-2.0-managed-test\r\n"); err != nil { + return err + } + <-ctx.Done() + return ctx.Err() + }) + defer func() { _ = conn.Close() }() + + _, err := ClientFromManagedConn(context.Background(), conn, ManagedClientOptions{ + HandshakeIdleTimeout: 40 * time.Millisecond, + HandshakeMaxTimeout: time.Second, + }) + + var timeoutErr *HandshakeTimeoutError + require.ErrorAs(t, err, &timeoutErr) + assert.Equal(t, 40*time.Millisecond, timeoutErr.idle) +} + +func TestClientFromManagedConnEnforcesHandshakeMaximum(t *testing.T) { + conn := openManagedTestConn(t, func(ctx context.Context, peer net.Conn) error { + if _, err := readSSHIdentification(peer); err != nil { + return err + } + if _, err := io.WriteString(peer, "SSH-2.0-managed-test\r\n"); err != nil { + return err + } + <-ctx.Done() + return ctx.Err() + }) + defer func() { _ = conn.Close() }() + + _, err := ClientFromManagedConn(context.Background(), conn, ManagedClientOptions{ + HandshakeIdleTimeout: 500 * time.Millisecond, + HandshakeMaxTimeout: 40 * time.Millisecond, + }) + + var timeoutErr *HandshakeTimeoutError + require.ErrorAs(t, err, &timeoutErr) + assert.Equal(t, 40*time.Millisecond, timeoutErr.idle) +} + +func TestClientFromManagedConnCancellationClosesTransport(t *testing.T) { + callbackDone := make(chan struct{}) + conn := openManagedTestConn(t, func(ctx context.Context, _ net.Conn) error { + defer close(callbackDone) + <-ctx.Done() + return ctx.Err() + }) + ctx, cancel := context.WithCancel(context.Background()) + dialDone := make(chan error, 1) + go func() { + _, err := ClientFromManagedConn(ctx, conn, ManagedClientOptions{}) + dialDone <- err + }() + + cancel() + select { + case err := <-dialDone: + require.ErrorIs(t, err, context.Canceled) + case <-time.After(time.Second): + t.Fatal("managed SSH dial did not stop after cancellation") + } + select { + case <-callbackDone: + case <-time.After(time.Second): + t.Fatal("managed transport callback was not terminated") + } + _ = conn.Close() +} + +type testManagedConn struct { + net.Conn + peer net.Conn + cancel context.CancelFunc + done chan error + once sync.Once +} + +func (c *testManagedConn) Wait() error { return <-c.done } + +func (c *testManagedConn) Close() error { + var err error + c.once.Do(func() { + c.cancel() + err = c.Conn.Close() + _ = c.peer.Close() + }) + return err +} + +func openManagedTestConn( + t *testing.T, + callback func(context.Context, net.Conn) error, +) *testManagedConn { + t.Helper() + listener, err := net.Listen("tcp", "127.0.0.1:0") + require.NoError(t, err) + defer func() { _ = listener.Close() }() + clientConn, err := net.Dial("tcp", listener.Addr().String()) + require.NoError(t, err) + peer, err := listener.Accept() + require.NoError(t, err) + ctx, cancel := context.WithCancel(context.Background()) + conn := &testManagedConn{ + Conn: clientConn, peer: peer, cancel: cancel, done: make(chan error, 1), + } + go func() { + err := callback(ctx, peer) + conn.done <- err + _ = peer.Close() + }() + t.Cleanup(func() { _ = conn.Close() }) + return conn +} + +func testServerConfig(t *testing.T) *xssh.ServerConfig { + t.Helper() + key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) + require.NoError(t, err) + signer, err := xssh.NewSignerFromKey(key) + require.NoError(t, err) + config := &xssh.ServerConfig{NoClientAuth: true} + config.AddHostKey(signer) + return config +} + +func serveTestSSH(ctx context.Context, peer net.Conn, config *xssh.ServerConfig) error { + serverConn, channels, requests, err := xssh.NewServerConn(peer, config) + if err != nil { + return err + } + go xssh.DiscardRequests(requests) + go func() { + for channel := range channels { + _ = channel.Reject(xssh.UnknownChannelType, "test") + } + }() + <-ctx.Done() + _ = serverConn.Close() + return ctx.Err() +} + +func readSSHIdentification(conn net.Conn) (string, error) { + return bufio.NewReader(conn).ReadString('\n') +} + +func TestApplicationCodeUsesManagedSSHDialer(t *testing.T) { + root := filepath.Clean(filepath.Join("..", "..")) + assertNoDirectSSHClientCall(t, filepath.Join(root, "cmd"), "") + assertNoDirectSSHClientCall(t, filepath.Join(root, "pkg"), filepath.Join(root, "pkg", "ssh")) +} + +func assertNoDirectSSHClientCall(t *testing.T, base, excludedDir string) { + t.Helper() + for _, path := range applicationGoFiles(t, base, excludedDir) { + contents, err := os.ReadFile( // #nosec G304 -- path comes from the repository walk root. + path, + ) + require.NoError(t, err) + if strings.Contains(string(contents), ".ClientFromConn(") { + t.Errorf( + "%s calls ClientFromConn outside pkg/ssh; classify readiness and use ClientFromManagedConn for managed transports", + path, + ) + } + } +} + +func applicationGoFiles(t *testing.T, base, excludedDir string) []string { + t.Helper() + var paths []string + err := filepath.WalkDir(base, func(path string, entry os.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } + if entry.IsDir() { + if excludedDir != "" && path == excludedDir { + return filepath.SkipDir + } + return nil + } + if filepath.Ext(path) != ".go" || strings.HasSuffix(path, "_test.go") { + return nil + } + paths = append(paths, path) + return nil + }) + require.NoError(t, err) + return paths +} diff --git a/pkg/tunnel/browser.go b/pkg/tunnel/browser.go index 7c4709318e..80a71fcfb2 100644 --- a/pkg/tunnel/browser.go +++ b/pkg/tunnel/browser.go @@ -66,7 +66,7 @@ func StartBrowserTunnel(ctx context.Context, p BrowserTunnelParams) error { } func startBrowserTunnelSSH(ctx context.Context, p BrowserTunnelParams) error { - return NewTunnel( + return NewManagedSSHTunnel( ctx, func(ctx context.Context, stdin io.Reader, stdout io.Writer) error { writer := log.Writer(log.LevelDebug) diff --git a/pkg/tunnel/container.go b/pkg/tunnel/container.go index 39a9be375f..5bd4cfff10 100644 --- a/pkg/tunnel/container.go +++ b/pkg/tunnel/container.go @@ -77,7 +77,7 @@ func (c *ContainerTunnel) Run( Workspace: c.client.Workspace(), TransportImpl: "callback", }, Handler: func(ctx context.Context) error { - sshClient, err := devssh.ClientFromConn(conn, "", nil) + sshClient, err := devssh.ClientFromManagedConn(ctx, conn, devssh.ManagedClientOptions{}) if err != nil { return fmt.Errorf("create ssh client: %w", err) } @@ -240,7 +240,9 @@ func (c *ContainerTunnel) runInContainer( TransportImpl: "ssh_session", }, Handler: func(ctx context.Context) error { - containerClient, err := devssh.ClientFromConn(containerConn, "", nil) + containerClient, err := devssh.ClientFromManagedConn( + ctx, containerConn, devssh.ManagedClientOptions{}, + ) if err != nil { return fmt.Errorf("ssh client: %w", err) } diff --git a/pkg/tunnel/direct.go b/pkg/tunnel/direct.go index 21fbf286da..b3ced6f34c 100644 --- a/pkg/tunnel/direct.go +++ b/pkg/tunnel/direct.go @@ -11,8 +11,8 @@ import ( // Tunnel defines the function to create an "outer" tunnel. type Tunnel func(ctx context.Context, stdin io.Reader, stdout io.Writer) error -// NewTunnel creates a managed SSH tunnel using generic transport callbacks. -func NewTunnel(ctx context.Context, tunnel Tunnel, handler Handler) error { +// NewManagedSSHTunnel creates an SSH tunnel whose callback may bootstrap its peer. +func NewManagedSSHTunnel(ctx context.Context, tunnel Tunnel, handler Handler) error { conn, err := transport.OpenCallbackConn( ctx, func(ctx context.Context, stdin io.Reader, stdout io.Writer) error { @@ -34,7 +34,7 @@ func NewTunnel(ctx context.Context, tunnel Tunnel, handler Handler) error { TransportSide: transport.SideProvider, Metadata: transport.LogMetadata{TransportImpl: "callback"}, Handler: func(ctx context.Context) error { - sshClient, err := devssh.ClientFromConn(conn, "", nil) + sshClient, err := devssh.ClientFromManagedConn(ctx, conn, devssh.ManagedClientOptions{}) if err != nil { return err } From cdc4a2d6346dab9c3266b6656218b41f2ab57a39 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sat, 26 Sep 2026 11:04:46 -0600 Subject: [PATCH 2/3] fix(ssh): preserve managed handshake errors --- pkg/ssh/managed_client.go | 43 ++++++-- pkg/ssh/managed_client_test.go | 183 ++++++++++++++++++++++++++++----- 2 files changed, 188 insertions(+), 38 deletions(-) diff --git a/pkg/ssh/managed_client.go b/pkg/ssh/managed_client.go index 46a3c7cc5c..cb1e45aa4b 100644 --- a/pkg/ssh/managed_client.go +++ b/pkg/ssh/managed_client.go @@ -207,7 +207,7 @@ func (d *managedSSHClientDialer) finishHandshake(res handshakeResult) (*xssh.Cli if !d.tracked.peerStarted.Load() || isManagedStreamEnd(res.err) { // A read reset before peer output can race the callback's terminal // bootstrap error. The managed result is authoritative in this phase. - res.err = managedTerminalError(d.ctx, d.transportDone) + res.err = d.managedStreamEndError(res.err) } d.closeConn() return nil, res.err @@ -216,19 +216,18 @@ func (d *managedSSHClientDialer) finishHandshake(res handshakeResult) (*xssh.Cli func (d *managedSSHClientDialer) finishTransport(transportErr error) (*xssh.Client, error) { if d.tracked.peerStarted.Load() { d.phase = managedSSHHandshake - } - // A completed launcher cannot produce more protocol bytes. Check a - // completed handshake first so a concrete SSH error is preserved. - select { - case res := <-d.result: + // Once peer bytes are observed, a completed callback cannot produce + // more protocol data. Closing unblocks the handshake goroutine; its + // concrete negotiation error takes precedence over the callback result. + d.closeConn() + res := <-d.result if res.err == nil { return d.newClient(res) } - if d.phase == managedSSHHandshake && !isManagedStreamEnd(res.err) { - d.closeConn() + if !isManagedStreamEnd(res.err) { return nil, res.err } - default: + return nil, managedErrorOrFallback(d.ctx, transportErr, res.err) } d.closeConn() if transportErr == nil { @@ -298,7 +297,7 @@ func (d *managedSSHClientDialer) finishTimeout(timeout time.Duration) (*xssh.Cli return d.newClient(res) } if isManagedStreamEnd(res.err) { - res.err = managedTerminalError(d.ctx, d.transportDone) + res.err = d.managedStreamEndError(res.err) } d.closeConn() return nil, res.err @@ -326,6 +325,30 @@ func (d *managedSSHClientDialer) closeConn() { _ = d.conn.Close() } +func (d *managedSSHClientDialer) managedStreamEndError(streamErr error) error { + select { + case terminalErr := <-d.transportDone: + return managedErrorOrFallback(d.ctx, terminalErr, streamErr) + default: + } + + // Closing first lets a blocked callback/process finish before Wait is joined. + d.closeConn() + terminalErr := managedTerminalError(d.ctx, d.transportDone) + return managedErrorOrFallback(d.ctx, terminalErr, streamErr) +} + +func managedErrorOrFallback(ctx context.Context, managedErr, fallback error) error { + if managedErr != nil && !errors.Is(managedErr, io.EOF) && + !errors.Is(managedErr, context.Canceled) && !errors.Is(managedErr, net.ErrClosed) { + return managedErr + } + if err := ctx.Err(); err != nil { + return err + } + return fallback +} + func managedTerminalError(ctx context.Context, transportDone <-chan error) error { select { case err := <-transportDone: diff --git a/pkg/ssh/managed_client_test.go b/pkg/ssh/managed_client_test.go index 78cb90ef2e..f511230482 100644 --- a/pkg/ssh/managed_client_test.go +++ b/pkg/ssh/managed_client_test.go @@ -93,6 +93,130 @@ func TestClientFromManagedConnReturnsBootstrapError(t *testing.T) { assert.NotErrorAs(t, err, &timeoutErr) } +func TestClientFromManagedConnClosesBeforeWaitingForTransport(t *testing.T) { + local, peer := net.Pipe() + conn := &waitGateManagedConn{ + Conn: local, waitStarted: make(chan struct{}), waitResult: make(chan error, 1), + waitReturned: make(chan struct{}), closed: make(chan struct{}), + } + defer func() { _ = peer.Close() }() + t.Cleanup(func() { + select { + case <-conn.waitReturned: + default: + conn.waitResult <- context.Canceled + } + _ = conn.Close() + }) + + peerClosed := make(chan struct{}) + go func() { + defer close(peerClosed) + _, _ = readSSHIdentification(peer) + _ = peer.Close() + }() + + wantErr := errors.New("container bootstrap failed") + dialDone := make(chan error, 1) + go func() { + _, err := ClientFromManagedConn(context.Background(), conn, ManagedClientOptions{}) + dialDone <- err + }() + + waitForSignal(t, conn.waitStarted, "managed transport Wait did not start") + waitForSignal(t, peerClosed, "SSH peer did not close its protocol stream") + select { + case <-conn.closed: + case <-time.After(time.Second): + conn.waitResult <- wantErr + t.Fatal("managed connection was not closed before waiting for transport completion") + } + select { + case <-conn.waitReturned: + t.Fatal("test transport completed before releasing Wait") + default: + } + + conn.waitResult <- wantErr + err := receiveTestError( + t, dialDone, "managed SSH dial did not finish after transport completion", + ) + require.ErrorIs(t, err, wantErr) +} + +func TestManagedDialerPreservesInvalidBannerErrorWhenTransportCompletesFirst(t *testing.T) { + sshErr := invalidSSHBannerError(t) + providerErr := errors.New("managed callback failed") + local, peer := net.Pipe() + defer func() { _ = peer.Close() }() + conn := &waitGateManagedConn{ + Conn: local, waitStarted: make(chan struct{}), waitResult: make(chan error, 1), + waitReturned: make(chan struct{}), closed: make(chan struct{}), + } + tracked := &managedHandshakeConn{Conn: conn, peerReady: make(chan struct{})} + tracked.peerStarted.Store(true) + dialer := &managedSSHClientDialer{ + ctx: context.Background(), conn: conn, tracked: tracked, + result: make(chan handshakeResult, 1), transportDone: make(chan error, 1), + phase: managedSSHHandshake, + } + done := make(chan error, 1) + go func() { + _, err := dialer.finishTransport(providerErr) + done <- err + }() + + select { + case <-conn.closed: + case <-time.After(time.Second): + t.Fatal("managed connection was not closed") + } + dialer.result <- handshakeResult{err: sshErr} + select { + case err := <-done: + require.ErrorIs(t, err, sshErr) + require.NotErrorIs(t, err, providerErr) + case <-time.After(time.Second): + t.Fatal("managed dialer did not collect the completed handshake error") + } +} + +func invalidSSHBannerError(t *testing.T) error { + t.Helper() + client, peer := net.Pipe() + defer func() { _ = client.Close() }() + defer func() { _ = peer.Close() }() + config, err := ConfigFromKeyBytes(nil) + require.NoError(t, err) + go func() { + _, _ = readSSHIdentification(peer) + _, _ = io.WriteString(peer, "SSH-"+strings.Repeat("A", 251)) + }() + _, _, _, err = xssh.NewClientConn(client, "stdio", config) + require.Error(t, err) + return err +} + +func waitForSignal(t *testing.T, signal <-chan struct{}, failure string) { + t.Helper() + select { + case <-signal: + case <-time.After(time.Second): + t.Fatal(failure) + } +} + +func receiveTestError(t *testing.T, result <-chan error, failure string) error { + t.Helper() + select { + case err := <-result: + return err + case <-time.After(time.Second): + t.Fatal(failure) + return nil + } +} + type resetOnStreamEndManagedConn struct{ *testManagedConn } func (c *resetOnStreamEndManagedConn) Read(p []byte) (int, error) { @@ -256,45 +380,48 @@ func readSSHIdentification(conn net.Conn) (string, error) { func TestApplicationCodeUsesManagedSSHDialer(t *testing.T) { root := filepath.Clean(filepath.Join("..", "..")) - assertNoDirectSSHClientCall(t, filepath.Join(root, "cmd"), "") - assertNoDirectSSHClientCall(t, filepath.Join(root, "pkg"), filepath.Join(root, "pkg", "ssh")) -} - -func assertNoDirectSSHClientCall(t *testing.T, base, excludedDir string) { - t.Helper() - for _, path := range applicationGoFiles(t, base, excludedDir) { + managedCallSites := []string{ + "cmd/machine/ssh.go", + "cmd/workspace/ssh.go", + "pkg/devcontainer/sshtunnel/sshtunnel.go", + "pkg/tunnel/container.go", + "pkg/tunnel/direct.go", + } + for _, callSite := range managedCallSites { + path := filepath.Join(root, callSite) contents, err := os.ReadFile( // #nosec G304 -- path comes from the repository walk root. path, ) require.NoError(t, err) if strings.Contains(string(contents), ".ClientFromConn(") { t.Errorf( - "%s calls ClientFromConn outside pkg/ssh; classify readiness and use ClientFromManagedConn for managed transports", + "%s uses ClientFromConn on a managed SSH call site; use ClientFromManagedConn", path, ) } } } -func applicationGoFiles(t *testing.T, base, excludedDir string) []string { - t.Helper() - var paths []string - err := filepath.WalkDir(base, func(path string, entry os.DirEntry, walkErr error) error { - if walkErr != nil { - return walkErr - } - if entry.IsDir() { - if excludedDir != "" && path == excludedDir { - return filepath.SkipDir - } - return nil - } - if filepath.Ext(path) != ".go" || strings.HasSuffix(path, "_test.go") { - return nil - } - paths = append(paths, path) - return nil +type waitGateManagedConn struct { + net.Conn + waitStarted chan struct{} + waitResult chan error + waitReturned chan struct{} + closed chan struct{} + closeOnce sync.Once +} + +func (c *waitGateManagedConn) Wait() error { + close(c.waitStarted) + err := <-c.waitResult + close(c.waitReturned) + return err +} + +func (c *waitGateManagedConn) Close() error { + c.closeOnce.Do(func() { + close(c.closed) + _ = c.Conn.Close() }) - require.NoError(t, err) - return paths + return nil } From 0529fdec2cfa82db06d9b85f6c81f5ccbe9864e6 Mon Sep 17 00:00:00 2001 From: Samuel K Date: Sat, 26 Sep 2026 14:58:07 -0600 Subject: [PATCH 3/3] test(ssh): widen delayed bootstrap timing --- pkg/ssh/managed_client_test.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pkg/ssh/managed_client_test.go b/pkg/ssh/managed_client_test.go index f511230482..8ba6c0e8eb 100644 --- a/pkg/ssh/managed_client_test.go +++ b/pkg/ssh/managed_client_test.go @@ -45,8 +45,8 @@ func TestClientFromManagedConnAllowsDelayedBootstrap(t *testing.T) { }, 1) go func() { client, err := ClientFromManagedConn(ctx, conn, ManagedClientOptions{ - HandshakeIdleTimeout: 20 * time.Millisecond, - HandshakeMaxTimeout: time.Second, + HandshakeIdleTimeout: 250 * time.Millisecond, + HandshakeMaxTimeout: 5 * time.Second, }) dialDone <- struct { client *xssh.Client @@ -61,7 +61,7 @@ func TestClientFromManagedConnAllowsDelayedBootstrap(t *testing.T) { _ = result.client.Close() } t.Fatalf("managed dial ended during bootstrap: %v", result.err) - case <-time.After(100 * time.Millisecond): + case <-time.After(500 * time.Millisecond): } close(release) @@ -70,7 +70,7 @@ func TestClientFromManagedConnAllowsDelayedBootstrap(t *testing.T) { require.NoError(t, result.err) require.NotNil(t, result.client) _ = result.client.Close() - case <-time.After(3 * time.Second): + case <-time.After(10 * time.Second): t.Fatal("managed SSH handshake did not complete") } }