Files
tailscale/ssh/tailssh/process_unix.go
James Tucker 9e396012a8 ssh/tailssh: stop killing session processes on graceful disconnects
Monitor teardown SIGHUPed and SIGKILLed every remembered child group
when the transport closed. sshd signals nothing at a non-PTY session
end; background jobs with redirected stdio survive and reparent to
init. Clients rely on that: VS Code Remote-SSH starts its remote
server as a plain background job in the session's group and expects
it to outlive connection drops, and tailscale upgrades run as
non-PTY execs whose work should survive a daemon restart.

Now only SSHTerminationError causes (revocation, session-duration,
recording failure) kill the process tree. Everything else — client
disconnect, daemon shutdown — closes I/O without signals: PTY masters
close and the driver SIGHUPs the foreground group, non-PTY processes
exit on EOF and SIGPIPE or keep running. Monitor teardown kills only
forwarding children, unless revocation armed the new kill-all op
first, since its per-session kicks race the close. No zombie leak:
the monitor reaps its table, and reparented survivors are reaped by
init.

Fixes #22076

Signed-off-by: James Tucker <[email protected]>

Change-Id: I70b4ef40035330dd542d256ba79d889a12426a74
2026-10-30 04:24:56 +00:00

213 lines
7.2 KiB
Go

// Copyright (c) Tailscale Inc & contributors
// SPDX-License-Identifier: BSD-3-Clause
//go:build (linux && !android) || (darwin && !ios) || freebsd || openbsd || plan9
package tailssh
import (
"encoding/json"
"errors"
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"syscall"
"time"
gliderssh "github.com/tailscale/gliderssh"
)
// monitorProcess identifies one exec child. ID is the exec request ID, which
// distinguishes successive children even when the operating system reuses a PID.
type monitorProcess struct {
PID int
ID int64
}
// monExitStatus publishes an exit code to any number of waiters. The registry
// completes it once; code may be read only after done is closed.
type monExitStatus struct {
done chan struct{}
code int
}
// osSessionState holds the platform-specific state of an [sshSession]'s
// process. It is embedded in [sshSession] and initialized by launchProcess.
//
// cmd describes the invocation on both paths. monChild identifies a monitor
// child; cmd.Process identifies a directly launched child.
type osSessionState struct {
// cmd is the session's incubator or shell process on the direct path.
// It is set but never started on the monitor path.
cmd *exec.Cmd
monChild monitorProcess // zero on the direct path
// monExit publishes the exit status, or 128+signal for a signaled death.
monExit *monExitStatus
// monDead is closed when the monitor's RPC channel is gone, so
// waiting sessions fail instead of blocking.
monDead <-chan struct{}
}
// forwardedEnvChildFD is the fd the incubator child reads the forwarded environment from, sent via
// --env-fd. It must match the payload file's index in launchProcess's ExtraFiles (fd = 3 + index).
const forwardedEnvChildFD = 3
// forwardedEnvFile returns the read end of a pipe holding the JSON-encoded forwarded pairs.
// The read end is passed to the incubator child via exec.Cmd.ExtraFiles to communicate
// secrets and config; the payload only ever exists in memory, never on any filesystem. A
// goroutine writes the payload and closes the write end. Caller must close the read end
// after the child starts.
func forwardedEnvFile(forwardedEnv []string) (*os.File, error) {
if len(forwardedEnv) == 0 {
return nil, errors.New("no forwarded environment")
}
b, err := json.Marshal(forwardedEnv)
if err != nil {
return nil, fmt.Errorf("marshaling forwarded environment: %w", err)
}
r, w, err := os.Pipe()
if err != nil {
return nil, fmt.Errorf("creating forwarded environment pipe: %w", err)
}
go func() {
defer w.Close()
// A short read fails the session child-side
_, _ = w.Write(b)
}()
return r, nil
}
// canSwitchToLocalUser reports whether this process can run a session as lu.
// A non-root tailscaled can only run sessions as itself.
func canSwitchToLocalUser(lu *userMeta) error {
if euid := os.Geteuid(); euid != 0 && runtime.GOOS != "plan9" {
if lu.Uid != fmt.Sprint(euid) {
return fmt.Errorf("can't switch to user %q from process euid %v", lu.Username, euid)
}
}
return nil
}
// waitProcess waits for the session's process to exit and returns its exit
// code. A non-nil error means the exit code could not be determined.
func (ss *sshSession) waitProcess() (exitCode int, err error) {
// Monitor path: the child's exit arrives as the monitor's async
// exit notification, with the code documented on monExit.
if code, ok, merr := ss.waitMonitorProcess(); ok {
return code, merr
}
err = ss.cmd.Wait()
if err == nil {
return 0, nil
}
if ee, ok := errors.AsType[*exec.ExitError](err); ok {
return ee.ProcessState.ExitCode(), nil
}
return 1, err
}
// hangupProcess ends the session process. PTY masters are always
// closed, and the terminal driver then SIGHUPs the foreground process
// group. When mandated is true the process group is also sent SIGHUP
// directly, then SIGKILL after the escalation delay. When mandated is
// false nothing else is signaled, matching sshd, and the process exits
// when its stdio is closed.
func (ss *sshSession) hangupProcess(mandated bool) {
if ss.ptyReq != nil {
// Close every PTY master descriptor so the terminal driver sends SIGHUP.
closeAll(ss.wrStdin, ss.rdStdout, ss.ptyResize)
if !mandated {
// Not mandated, so closing the PTY and the SIGHUP that
// follows from it is enough.
return
}
}
if ss.hangupMonitorProcess(mandated) {
return
}
if ss.cmd == nil || ss.cmd.Process == nil {
return
}
p := ss.cmd.Process
// The process handle synchronizes signaling with exit and reaping.
if !mandated {
// Not mandated, so do not signal. The process exits when its
// stdio is closed.
return
}
if ss.ptyReq == nil {
p.Signal(syscall.SIGHUP)
}
time.AfterFunc(knobDuration(sshHupEscalation(), defaultHupEscalation), func() {
p.Signal(syscall.SIGKILL)
})
}
// systemHostKeyFile returns the path of the system's OpenSSH host key of the
// given type ("rsa", "ecdsa", "ed25519") for tailssh to reuse, or "" to
// generate its own key instead. Only root can read the system keys.
func systemHostKeyFile(typ string) string {
if os.Geteuid() != 0 {
return ""
}
return "/etc/ssh/ssh_host_" + typ + "_key"
}
// handleSSHAgentForwarding starts a Unix socket listener and in the background
// forwards agent connections between the listener and the gliderssh.Session.
// On success, it assigns ss.agentListener.
//
// The listener and its containing directory are created by a user-cred
// child through conn.fwdListenAgent. See the docs there for the modes.
func (ss *sshSession) handleSSHAgentForwarding(s gliderssh.Session, lu *userMeta) error {
if !gliderssh.AgentRequested(ss) || !ss.conn.finalAction.AllowAgentForwarding {
return nil
}
// The latched AllowAgentForwarding bit may be stale. See recheckPolicy.
if !ss.conn.recheckPolicy() {
return nil
}
if sshDisableForwarding() {
// TODO(bradfitz): or do we want to return an error here instead so the user
// gets an error if they ran with ssh -A? But for now we just silently
// don't work, like the condition above.
return nil
}
ss.logf("ssh: agent forwarding requested")
ln, socket, err := ss.conn.fwdListenAgent(s.Context(), lu)
if err != nil {
return err
}
// The listener's own address is the kernel's bound path; socket is
// the path the child reported and the monitor validated. They must
// agree: the cleanup removes the directory of the validated path, so
// a child whose report and actual bind disagree is refused.
if got := ln.Addr().String(); got != socket {
ln.Close()
return fmt.Errorf("agent forwarding socket path %q does not match the listener's bound path %q", socket, got)
}
ss.agentListener = ln
go gliderssh.ForwardAgentConnections(ln, s)
return nil
}
// closeAgentForwarding closes the agent forwarding listener and removes the
// temporary directory that holds its socket, so neither outlives the
// session. The removal rules are platform-specific: on the monitor
// platforms the directory was created by a user-cred child while the
// removal runs with the daemon's credentials; see
// removeAgentForwardingDir in fwdmonitor.go and fwdplan9.go.
func (ss *sshSession) closeAgentForwarding() {
ln := ss.agentListener
if ln == nil {
return
}
ss.agentListener = nil
dir := filepath.Dir(ln.Addr().String())
ln.Close()
removeAgentForwardingDir(dir, ss.conn.localUser, ss.logf)
}