Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions cmd/internal/agentcontainer/container.go
Original file line number Diff line number Diff line change
Expand Up @@ -31,5 +31,6 @@ func NewContainerCmd(flags *flags.GlobalFlags) *cobra.Command {
containerCmd.AddCommand(NewCredentialsStatusCmd())
containerCmd.AddCommand(NewSetupDevsyPlatformAccessCmd(flags))
containerCmd.AddCommand(NewSSHServerCmd(flags))
containerCmd.AddCommand(NewSFTPServerCmd())
return containerCmd
}
36 changes: 36 additions & 0 deletions cmd/internal/agentcontainer/sftp_server.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,36 @@
package agentcontainer

import (
"fmt"
"io"
"os"

"github.com/devsy-org/devsy/pkg/ssh/server"
"github.com/spf13/cobra"
)

func NewSFTPServerCmd() *cobra.Command {
var home string
cmd := &cobra.Command{
Use: "sftp-server",
Hidden: true,
Args: cobra.NoArgs,
RunE: func(_ *cobra.Command, _ []string) error {
if home == "" {
return fmt.Errorf("home directory is required")
}
return server.ServeSFTP(sftpStdio{Reader: os.Stdin, Writer: os.Stdout}, home)
},
}
cmd.Flags().StringVar(&home, "home", "", "Home directory for SFTP paths")
return cmd
}

type sftpStdio struct {
io.Reader
io.Writer
}

func (sftpStdio) Close() error {
return nil
}
24 changes: 24 additions & 0 deletions pkg/ssh/server/exec_identity_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -167,6 +167,30 @@ func TestSameEffectiveGroupIDsIgnoresOrderDuplicatesAndPrimaryRepresentation(t *
require.False(t, sameEffectiveGroupIDs(201, nil, 201, []int{-1}))
}

func TestPrepareExecIdentityForNamedSFTPAccountRetainsGroups(t *testing.T) {
account, lookups := execIdentityTestLookups()
lookups.userByID = func(id string) (*user.User, error) {
require.Equal(t, account.Uid, id)
return &user.User{Username: "other", Uid: id, Gid: "3000", HomeDir: "/home/other"}, nil
}
lookups.groups = func(got *user.User) ([]string, error) {
require.Same(t, account, got)
return []string{"2001", "2002"}, nil
}

cmd := exec.Command("true")
handled, err := prepareExecIdentityForAccountWithLookups(cmd, account.Uid, account, lookups)
require.NoError(t, err)
require.True(t, handled)
require.NotNil(t, cmd.SysProcAttr)
require.NotNil(t, cmd.SysProcAttr.Credential)
require.Equal(t, uint32(1000), cmd.SysProcAttr.Credential.Uid)
require.Equal(t, uint32(2000), cmd.SysProcAttr.Credential.Gid)
require.Equal(t, []uint32{2001, 2002}, cmd.SysProcAttr.Credential.Groups)
require.Equal(t, "alice", environmentMap(cmd.Environ())["USER"])
require.Equal(t, "/home/alice", cmd.Dir)
}

func TestPrepareExecIdentityLeavesNamedUserToExistingPath(t *testing.T) {
cmd := exec.Command("true")
attrs := &syscall.SysProcAttr{Setpgid: true}
Expand Down
14 changes: 14 additions & 0 deletions pkg/ssh/server/exec_identity_unix.go
Original file line number Diff line number Diff line change
Expand Up @@ -38,6 +38,20 @@ func prepareExecIdentity(cmd *exec.Cmd, spec string) (bool, error) {
return prepareExecIdentityWithLookups(cmd, spec, systemExecIdentityLookups())
}

func prepareExecIdentityForAccount(cmd *exec.Cmd, spec string, account *user.User) (bool, error) {
return prepareExecIdentityForAccountWithLookups(cmd, spec, account, systemExecIdentityLookups())
}

func prepareExecIdentityForAccountWithLookups(
cmd *exec.Cmd,
spec string,
account *user.User,
lookups execIdentityLookups,
) (bool, error) {
lookups.userByID = func(string) (*user.User, error) { return account, nil }
return prepareExecIdentityWithLookups(cmd, spec, lookups)
}

func prepareExecIdentityWithLookups(
cmd *exec.Cmd,
spec string,
Expand Down
5 changes: 5 additions & 0 deletions pkg/ssh/server/exec_identity_windows.go
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@ package server
import (
"errors"
"os/exec"
"os/user"
)

func prepareExecIdentity(_ *exec.Cmd, spec string) (bool, error) {
Expand All @@ -14,3 +15,7 @@ func prepareExecIdentity(_ *exec.Cmd, spec string) (bool, error) {
}
return true, errors.New("numeric execution identities are not supported on Windows")
}

func prepareExecIdentityForAccount(cmd *exec.Cmd, spec string, _ *user.User) (bool, error) {
return prepareExecIdentity(cmd, spec)
}
183 changes: 158 additions & 25 deletions pkg/ssh/server/sftp_handler.go
Original file line number Diff line number Diff line change
@@ -1,48 +1,181 @@
package server

import (
"context"
"errors"
"fmt"
"io"
"os"
"os/exec"
"os/user"
"runtime"
"strconv"

"github.com/devsy-org/devsy/pkg/command"
"github.com/devsy-org/devsy/pkg/log"
"github.com/devsy-org/ssh"
"github.com/pkg/sftp"
)

func sftpHandler(sess ssh.Session, currentUser string) {
writer := log.Writer(log.LevelDebug)
defer func() { _ = writer.Close() }()
var newSFTPCommand = func(_ context.Context, home string) (*exec.Cmd, error) {
executable, err := os.Executable()
if err != nil {
return nil, err
}
return &exec.Cmd{
Path: executable,
Args: []string{executable, "internal", "agent", "container", "sftp-server", "--home", home},
}, nil
}

user := sess.User()
if user == currentUser {
user = ""
type sftpExecIdentity struct {
home string
credential string
account *user.User
hasGroupSpec bool
}

func sftpHandler(sess ssh.Session) {
err := runSFTP(sess)
if err != nil {
log.Debugf("sftp session failed: %v (exit %d)", err, exitCode(err))
}
if err := sess.Exit(exitCode(err)); err != nil {
log.Debugf("sftp session exit failed: %T", err)
}
}

workingDir, _ := command.GetHome(user)
serverOptions := []sftp.ServerOption{
sftp.WithDebug(writer),
sftp.WithServerWorkingDirectory(workingDir),
func runSFTP(sess ssh.Session) error {
identity, err := resolveSFTPIdentity(sess.User())
if err != nil {
return err
}
server, err := sftp.NewServer(
sess,
serverOptions...,
)
cmd, err := newSFTPCommand(sess.Context(), identity.home)
if err != nil {
log.Debugf("sftp server init error: %s\n", err)
return
return err
}
defer func() { _ = server.Close() }()
if cmd == nil {
return errors.New("missing SFTP command")
}
if err := prepareSFTPCommand(cmd, identity); err != nil {
return err
}
cmd.Stdout = sess
cmd.Stderr = sess.Stderr()
stdin, err := cmd.StdinPipe()
if err != nil {
return err
}
if err := cmd.Start(); err != nil {
_ = stdin.Close()
return err
}
stopCancellation := context.AfterFunc(sess.Context(), func() { _ = cmd.Process.Kill() })
defer stopCancellation()
go func() {
_, _ = io.Copy(stdin, sess)
_ = stdin.Close()
}()
return cmd.Wait()
}

// serve
err = server.Serve()
if errors.Is(err, io.EOF) {
_ = sess.Exit(0)
return
func resolveSFTPIdentity(spec string) (sftpExecIdentity, error) {
if spec == "" {
return sftpExecIdentity{}, errors.New("missing SFTP user")
}
requested, handled, err := parseRequestedExecIdentity(spec)
if err != nil {
return sftpExecIdentity{}, err
}
if !handled {
requested.user = spec
}
account, err := lookupSFTPAccount(requested)
if err != nil {
return sftpExecIdentity{}, err
}
identity := sftpExecIdentity{
home: "/",
credential: spec,
account: account,
hasGroupSpec: requested.hasGroupSpec,
}
if account != nil {
if account.HomeDir != "" {
identity.home = account.HomeDir
}
if !requested.hasGroupSpec {
identity.credential = account.Uid
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
}
}
return identity, nil
}

func lookupSFTPAccount(requested requestedExecIdentity) (*user.User, error) {
if !requested.userIsID {
return user.Lookup(requested.user)
}
uid, err := parseExecID(requested.user)
if err != nil {
return nil, err
}
account, err := user.LookupId(strconv.FormatUint(uint64(uid), 10))
var unknown user.UnknownUserIdError
if err != nil && !errors.As(err, &unknown) {
return nil, err
}
return account, nil
}

func prepareSFTPCommand(cmd *exec.Cmd, identity sftpExecIdentity) error {
handled, err := applySFTPCredentials(cmd, identity)
if err != nil {
return err
}
if !handled {
return fmt.Errorf("SFTP identity %q cannot be applied", identity.credential)
}
if runtime.GOOS != "windows" {
cmd.Dir = "/"
}
return nil
}

func applySFTPCredentials(cmd *exec.Cmd, identity sftpExecIdentity) (bool, error) {
if identity.account != nil && !identity.hasGroupSpec {
current, err := user.Current()
if err != nil {
return true, err
}
if identity.account.Uid == current.Uid && identity.account.Username == current.Username {
prepareCurrentSFTPUser(cmd, identity)
return true, nil
}
if runtime.GOOS == "windows" {
return true, errors.New("SFTP user switching is not supported")
}
return prepareExecIdentityForAccount(cmd, identity.credential, identity.account)
}
return prepareExecIdentity(cmd, identity.credential)
}

func prepareCurrentSFTPUser(cmd *exec.Cmd, identity sftpExecIdentity) {
cmd.Env = mergeSessionEnvironment(cmd.Environ(), []string{
"HOME=" + identity.home,
"USER=" + identity.account.Username,
"LOGNAME=" + identity.account.Username,
}, nil)
}

func ServeSFTP(input io.ReadWriteCloser, home string) error {
server, err := sftp.NewServer(input, sftp.WithServerWorkingDirectory(home))
if err != nil {
log.Debugf("sftp server completed with error: %v", err)
return err
}
defer func() { _ = server.Close() }()

err = server.Serve()
if errors.Is(err, io.EOF) {
return nil
}
_ = sess.Exit(1)
return err
}
Loading
Loading