Skip to content

"rsync for cloud storage" - Google Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Wasabi, Google Cloud Storage, Azure Blob, Azure Files, Yandex Files

serve sftp: don't crash the whole server on a bad request GHSA-6jcg-q3wp-x2f4

Nick Craig-Wood50b4d4c74570
diff --git a/cmd/serve/sftp/connection.go b/cmd/serve/sftp/connection.go
index b869eaad6..28650e268 100644
--- a/cmd/serve/sftp/connection.go
+++ b/cmd/serve/sftp/connection.go
@@ -57,6 +57,7 @@ type conn struct {
// execCommand implements an extremely limited number of commands to
// interoperate with the rclone sftp backend
func (c *conn) execCommand(ctx context.Context, out io.Writer, command string) (err error) {
+ defer recoverPanic(&err)
binary, args := command, ""
before, after, ok := strings.Cut(command, " ")
if ok {
@@ -269,6 +270,11 @@ func (c *conn) handleChannel(newChannel ssh.NewChannel) {
// Handle out-of-band requests
go func(in <-chan *ssh.Request) {
+ // Unblock the main routine when the requests run out, otherwise a
+ // channel which never makes a supported request - because it was
+ // rejected, or was closed straight away - leaks this goroutine and
+ // the channel for the lifetime of the connection.
+ defer close(isSFTP)
for req := range in {
fs.Debugf(c.what, "Request: %v\n", req.Type)
ok := false
@@ -276,8 +282,15 @@ func (c *conn) handleChannel(newChannel ssh.NewChannel) {
var reply []byte
switch req.Type {
case "subsystem":
- fs.Debugf(c.what, "Subsystem: %s\n", req.Payload[4:])
- if string(req.Payload[4:]) == "sftp" {
+ // The payload is a length-prefixed string, so it must be
+ // decoded rather than sliced to avoid panics if too short.
+ var subsystem struct{ Name string }
+ if err := ssh.Unmarshal(req.Payload, &subsystem); err != nil {
+ fs.Errorf(c.what, "ignoring bad subsystem request: %v", err)
+ break
+ }
+ fs.Debugf(c.what, "Subsystem: %s\n", subsystem.Name)
+ if subsystem.Name == "sftp" {
ok = true
subSystemIsSFTP = true
}
@@ -304,7 +317,12 @@ func (c *conn) handleChannel(newChannel ssh.NewChannel) {
}(requests)
// Wait for either subsystem "sftp" or "exec" request
- if <-isSFTP {
+ subSystemIsSFTP, ok := <-isSFTP
+ if !ok {
+ fs.Debugf(c.what, "Channel closed without a supported request")
+ return
+ }
+ if subSystemIsSFTP {
if err := serveChannel(channel, c.handlers, c.what); err != nil {
fs.Errorf(c.what, "Failed to serve SFTP: %v", err)
}
diff --git a/cmd/serve/sftp/handler.go b/cmd/serve/sftp/handler.go
index 1ce26e062..8cb7e522a 100644
--- a/cmd/serve/sftp/handler.go
+++ b/cmd/serve/sftp/handler.go
@@ -3,8 +3,10 @@
package sftp
import (
+ "fmt"
"io"
"os"
+ "runtime/debug"
"syscall"
"time"
@@ -13,6 +15,36 @@ import (
"github.com/rclone/rclone/vfs"
)
+// recoverPanic turns a panic into an error assigned through err.
+func recoverPanic(err *error) {
+ if r := recover(); r != nil {
+ fs.Errorf("sftp", "panic in request handler: %v\n%s", r, debug.Stack())
+ *err = fmt.Errorf("request handler: %v", r)
+ }
+}
+
+// recoveringHandle wraps a vfs.Handle so panics in ReadAt and WriteAt,
+// which pkg/sftp calls from its packet worker goroutines, are returned
+// as errors.
+type recoveringHandle struct {
+ vfs.Handle
+}
+
+func (h recoveringHandle) ReadAt(b []byte, off int64) (n int, err error) {
+ defer recoverPanic(&err)
+ return h.Handle.ReadAt(b, off)
+}
+
+func (h recoveringHandle) WriteAt(b []byte, off int64) (n int, err error) {
+ defer recoverPanic(&err)
+ return h.Handle.WriteAt(b, off)
+}
+
+func (h recoveringHandle) Close() (err error) {
+ defer recoverPanic(&err)
+ return h.Handle.Close()
+}
+
// vfsHandler converts the VFS to be served by SFTP
type vfsHandler struct {
*vfs.VFS
@@ -29,15 +61,17 @@ func newVFSHandler(vfs *vfs.VFS) sftp.Handlers {
}
}
-func (v vfsHandler) Fileread(r *sftp.Request) (io.ReaderAt, error) {
+func (v vfsHandler) Fileread(r *sftp.Request) (ra io.ReaderAt, err error) {
+ defer recoverPanic(&err)
file, err := v.OpenFile(r.Filepath, os.O_RDONLY, 0777)
if err != nil {
return nil, err
}
- return file, nil
+ return recoveringHandle{file}, nil
}
-func (v vfsHandler) Filewrite(r *sftp.Request) (io.WriterAt, error) {
+func (v vfsHandler) Filewrite(r *sftp.Request) (wa io.WriterAt, err error) {
+ defer recoverPanic(&err)
// Respect the flags requested in the SFTP OPEN packet
p := r.Pflags()
flags := os.O_WRONLY
@@ -57,10 +91,11 @@ func (v vfsHandler) Filewrite(r *sftp.Request) (io.WriterAt, error) {
if err != nil {
return nil, err
}
- return file, nil
+ return recoveringHandle{file}, nil
}
-func (v vfsHandler) Filecmd(r *sftp.Request) error {
+func (v vfsHandler) Filecmd(r *sftp.Request) (err error) {
+ defer recoverPanic(&err)
switch r.Method {
case "Setstat":
attr := r.Attributes()
@@ -119,7 +154,8 @@ func (v vfsHandler) Filecmd(r *sftp.Request) error {
// StatVFS implements the [email protected] extension, returning filesystem
// usage information from the VFS. It satisfies sftp.StatVFSFileCmder.
-func (v vfsHandler) StatVFS(r *sftp.Request) (*sftp.StatVFS, error) {
+func (v vfsHandler) StatVFS(r *sftp.Request) (st *sftp.StatVFS, err error) {
+ defer recoverPanic(&err)
const blockSize = 4096
total, _, free := v.Statfs()
blocks := uint64(total) / blockSize
@@ -140,8 +176,8 @@ func (v vfsHandler) StatVFS(r *sftp.Request) (*sftp.StatVFS, error) {
type listerat []os.FileInfo
// Modeled after strings.Reader's ReadAt() implementation
-func (f listerat) ListAt(ls []os.FileInfo, offset int64) (int, error) {
- var n int
+func (f listerat) ListAt(ls []os.FileInfo, offset int64) (n int, err error) {
+ defer recoverPanic(&err)
if offset >= int64(len(f)) {
return 0, io.EOF
}
@@ -153,6 +189,7 @@ func (f listerat) ListAt(ls []os.FileInfo, offset int64) (int, error) {
}
func (v vfsHandler) Filelist(r *sftp.Request) (l sftp.ListerAt, err error) {
+ defer recoverPanic(&err)
var node vfs.Node
var handle vfs.Handle
switch r.Method {
diff --git a/cmd/serve/sftp/handler_test.go b/cmd/serve/sftp/handler_test.go
index 32cdec212..27e7c1232 100644
--- a/cmd/serve/sftp/handler_test.go
+++ b/cmd/serve/sftp/handler_test.go
@@ -10,6 +10,7 @@ import (
"context"
"io"
"os"
+ "runtime"
"strings"
"testing"
"time"
@@ -18,15 +19,16 @@ import (
_ "github.com/rclone/rclone/backend/local"
"github.com/rclone/rclone/cmd/serve/proxy"
"github.com/rclone/rclone/fs"
+ "github.com/rclone/rclone/vfs"
"github.com/rclone/rclone/vfs/vfscommon"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/crypto/ssh"
)
-// startTestServer starts an sftp server serving a temporary local directory
-// with the given VFS options and returns a connected sftp client.
-func startTestServer(t *testing.T, vfsOpt *vfscommon.Options) *sftp.Client {
+// startTestSSHClient starts an sftp server serving a temporary local directory
+// with the given VFS options and returns an ssh client connected to it.
+func startTestSSHClient(t *testing.T, vfsOpt *vfscommon.Options) *ssh.Client {
ctx := context.Background()
f, err := fs.NewFs(ctx, t.TempDir())
@@ -57,7 +59,13 @@ func startTestServer(t *testing.T, vfsOpt *vfscommon.Options) *sftp.Client {
_ = conn.Close()
})
- client, err := sftp.NewClient(conn)
+ return conn
+}
+
+// startTestServer starts an sftp server as startTestSSHClient does and
+// returns a connected sftp client.
+func startTestServer(t *testing.T, vfsOpt *vfscommon.Options) *sftp.Client {
+ client, err := sftp.NewClient(startTestSSHClient(t, vfsOpt))
require.NoError(t, err)
t.Cleanup(func() {
_ = client.Close()
@@ -202,6 +210,91 @@ func TestSetstatMtime(t *testing.T) {
assert.True(t, fi.ModTime().Equal(epoch), "mtime not applied: got %v want %v", fi.ModTime(), epoch)
}
+// Test that a panic in a request handler is recovered and returned as an
+// error to the client rather than crashing the whole server.
+func TestHandlerRecoversPanic(t *testing.T) {
+ // A nil VFS makes every handler panic with a nil pointer dereference
+ // inside the vfs package, standing in for a panicking backend.
+ v := vfsHandler{}
+
+ _, err := v.Fileread(&sftp.Request{Filepath: "/file"})
+ assert.ErrorContains(t, err, "request handler")
+
+ _, err = v.Filewrite(&sftp.Request{Filepath: "/file"})
+ assert.ErrorContains(t, err, "request handler")
+
+ err = v.Filecmd(&sftp.Request{Method: "Mkdir", Filepath: "/dir"})
+ assert.ErrorContains(t, err, "request handler")
+
+ _, err = v.Filelist(&sftp.Request{Method: "List", Filepath: "/"})
+ assert.ErrorContains(t, err, "request handler")
+
+ _, err = v.StatVFS(&sftp.Request{Filepath: "/"})
+ assert.ErrorContains(t, err, "request handler")
+}
+
+// panickingHandle panics on ReadAt and WriteAt, standing in for a backend
+// which panics during data transfer.
+type panickingHandle struct {
+ vfs.Handle
+}
+
+func (panickingHandle) ReadAt([]byte, int64) (int, error) { panic("boom") }
+func (panickingHandle) WriteAt([]byte, int64) (int, error) { panic("boom") }
+func (panickingHandle) Close() error { panic("boom") }
+
+// Test that a panic during data transfer on a handle returned from
+// Fileread/Filewrite is recovered and returned as an error.
+func TestRecoveringHandle(t *testing.T) {
+ h := recoveringHandle{panickingHandle{}}
+
+ _, err := h.ReadAt(make([]byte, 16), 0)
+ assert.ErrorContains(t, err, "boom")
+
+ _, err = h.WriteAt(make([]byte, 16), 0)
+ assert.ErrorContains(t, err, "boom")
+
+ assert.ErrorContains(t, h.Close(), "boom")
+}
+
+// Test that a session request with a truncated payload is rejected rather
+// than panicking the out-of-band request goroutine, which would kill the
+// whole server. The subsystem payload is a length-prefixed string, so an
+// empty one used to be sliced out of range.
+func TestShortSubsystemRequest(t *testing.T) {
+ vfsOpt := vfscommon.Opt
+ conn := startTestSSHClient(t, &vfsOpt)
+
+ // Rejecting the request must not leak the goroutine waiting to find out
+ // what kind of channel this is, or a client could exhaust the server by
+ // opening bad channels in a loop.
+ before := runtime.NumGoroutine()
+ const channels = 50
+ for range channels {
+ channel, requests, err := conn.OpenChannel("session", nil)
+ require.NoError(t, err)
+ go ssh.DiscardRequests(requests)
+
+ // Empty payload: no 4-byte length prefix at all
+ _, err = channel.SendRequest("subsystem", true, []byte{})
+ require.NoError(t, err)
+ require.NoError(t, channel.Close())
+ }
+
+ assert.Eventually(t, func() bool {
+ return runtime.NumGoroutine() < before+channels/2
+ }, 10*time.Second, 50*time.Millisecond,
+ "goroutines leaked: started at %d, now %d after %d rejected channels",
+ before, runtime.NumGoroutine(), channels)
+
+ // The server must still be alive and serving
+ client, err := sftp.NewClient(conn)
+ require.NoError(t, err, "server died after a truncated subsystem request")
+ defer func() { _ = client.Close() }()
+ _, err = client.Stat("/")
+ assert.NoError(t, err)
+}
+
// writeFile writes contents to fileName via the client truncating any existing
// data, the way a normal upload does.
func writeFile(client *sftp.Client, fileName, contents string) error {