Skip to content

SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.

19.4 KB
Raw Blame
package sftp

import (
	"bytes"
	"io"
	"os"
	"path"
	"testing"

	"github.com/stretchr/testify/require"
)

// TestHomeDirPathTranslation tests that SFTP operations correctly translate
// paths relative to the user's HomeDir.
// This is the fix for https://github.com/seaweedfs/seaweedfs/issues/7470
func TestHomeDirPathTranslation(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test in short mode")
	}

	config := DefaultTestConfig()
	config.EnableDebug = testing.Verbose()

	fw := NewSftpTestFramework(t, config)
	err := fw.Setup(config)
	require.NoError(t, err, "failed to setup test framework")
	defer fw.Cleanup()

	// Test with user "testuser" who has HomeDir="/sftp/testuser"
	// When they upload to "/", it should actually go to "/sftp/testuser"
	sftpClient, sshConn, err := fw.ConnectSFTP("testuser", "testuserpassword")
	require.NoError(t, err, "failed to connect as testuser")
	defer sshConn.Close()
	defer sftpClient.Close()

	// Test 1: Upload file to "/" (should map to /sftp/testuser/)
	t.Run("UploadToRoot", func(t *testing.T) {
		testContent := []byte("Hello from SFTP test!")
		filename := "test_upload.txt"

		// Create file at "/" from user's perspective
		file, err := sftpClient.Create("/" + filename)
		require.NoError(t, err, "should be able to create file at /")

		_, err = file.Write(testContent)
		require.NoError(t, err, "should be able to write to file")
		err = file.Close()
		require.NoError(t, err, "should be able to close file")

		// Verify file exists and has correct content
		readFile, err := sftpClient.Open("/" + filename)
		require.NoError(t, err, "should be able to open file")
		defer readFile.Close()

		content, err := io.ReadAll(readFile)
		require.NoError(t, err, "should be able to read file")
		require.Equal(t, testContent, content, "file content should match")

		// Clean up
		err = sftpClient.Remove("/" + filename)
		require.NoError(t, err, "should be able to remove file")
	})

	// Test 2: Create directory at "/" (should map to /sftp/testuser/)
	t.Run("CreateDirAtRoot", func(t *testing.T) {
		dirname := "test_dir"

		err := sftpClient.Mkdir("/" + dirname)
		require.NoError(t, err, "should be able to create directory at /")

		// Verify directory exists
		info, err := sftpClient.Stat("/" + dirname)
		require.NoError(t, err, "should be able to stat directory")
		require.True(t, info.IsDir(), "should be a directory")

		// Clean up
		err = sftpClient.RemoveDirectory("/" + dirname)
		require.NoError(t, err, "should be able to remove directory")
	})

	// Test 3: List directory at "/" (should list /sftp/testuser/)
	t.Run("ListRoot", func(t *testing.T) {
		// Create a test file first
		testContent := []byte("list test content")
		filename := "list_test.txt"

		file, err := sftpClient.Create("/" + filename)
		require.NoError(t, err)
		_, err = file.Write(testContent)
		require.NoError(t, err)
		file.Close()

		// List root directory
		files, err := sftpClient.ReadDir("/")
		require.NoError(t, err, "should be able to list root directory")

		// Should find our test file
		found := false
		for _, f := range files {
			if f.Name() == filename {
				found = true
				break
			}
		}
		require.True(t, found, "should find test file in listing")

		// Clean up
		err = sftpClient.Remove("/" + filename)
		require.NoError(t, err)
	})

	// Test 4: Nested directory operations
	t.Run("NestedOperations", func(t *testing.T) {
		// Create nested directory structure
		err := sftpClient.MkdirAll("/nested/dir/structure")
		require.NoError(t, err, "should be able to create nested directories")

		// Create file in nested directory
		testContent := []byte("nested file content")
		file, err := sftpClient.Create("/nested/dir/structure/file.txt")
		require.NoError(t, err)
		_, err = file.Write(testContent)
		require.NoError(t, err)
		file.Close()

		// Verify file exists
		readFile, err := sftpClient.Open("/nested/dir/structure/file.txt")
		require.NoError(t, err)
		content, err := io.ReadAll(readFile)
		require.NoError(t, err)
		readFile.Close()
		require.Equal(t, testContent, content)

		// Clean up
		err = sftpClient.Remove("/nested/dir/structure/file.txt")
		require.NoError(t, err)
		err = sftpClient.RemoveDirectory("/nested/dir/structure")
		require.NoError(t, err)
		err = sftpClient.RemoveDirectory("/nested/dir")
		require.NoError(t, err)
		err = sftpClient.RemoveDirectory("/nested")
		require.NoError(t, err)
	})

	// Test 5: Rename operation
	t.Run("RenameFile", func(t *testing.T) {
		testContent := []byte("rename test content")

		file, err := sftpClient.Create("/original.txt")
		require.NoError(t, err)
		_, err = file.Write(testContent)
		require.NoError(t, err)
		file.Close()

		// Rename file
		err = sftpClient.Rename("/original.txt", "/renamed.txt")
		require.NoError(t, err, "should be able to rename file")

		// Verify old file doesn't exist
		_, err = sftpClient.Stat("/original.txt")
		require.Error(t, err, "original file should not exist")

		// Verify new file exists with correct content
		readFile, err := sftpClient.Open("/renamed.txt")
		require.NoError(t, err, "renamed file should exist")
		content, err := io.ReadAll(readFile)
		require.NoError(t, err)
		readFile.Close()
		require.Equal(t, testContent, content)

		// Clean up
		err = sftpClient.Remove("/renamed.txt")
		require.NoError(t, err)
	})
}

// TestAdminRootAccess tests that admin user with HomeDir="/" can access everything
func TestAdminRootAccess(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test in short mode")
	}

	config := DefaultTestConfig()
	config.EnableDebug = testing.Verbose()

	fw := NewSftpTestFramework(t, config)
	err := fw.Setup(config)
	require.NoError(t, err, "failed to setup test framework")
	defer fw.Cleanup()

	// Connect as admin with HomeDir="/"
	sftpClient, sshConn, err := fw.ConnectSFTP("admin", "adminpassword")
	require.NoError(t, err, "failed to connect as admin")
	defer sshConn.Close()
	defer sftpClient.Close()

	// Admin should be able to create directories anywhere
	t.Run("CreateAnyDirectory", func(t *testing.T) {
		// Create the user's home directory structure
		err := sftpClient.MkdirAll("/sftp/testuser")
		require.NoError(t, err, "admin should be able to create any directory")

		// Create file in that directory
		testContent := []byte("admin created this")
		file, err := sftpClient.Create("/sftp/testuser/admin_file.txt")
		require.NoError(t, err)
		_, err = file.Write(testContent)
		require.NoError(t, err)
		file.Close()

		// Verify file exists
		info, err := sftpClient.Stat("/sftp/testuser/admin_file.txt")
		require.NoError(t, err)
		require.False(t, info.IsDir())

		// Clean up
		err = sftpClient.Remove("/sftp/testuser/admin_file.txt")
		require.NoError(t, err)
	})
}

// TestLargeFileUpload tests uploading larger files through SFTP
func TestLargeFileUpload(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test in short mode")
	}

	config := DefaultTestConfig()
	config.EnableDebug = testing.Verbose()

	fw := NewSftpTestFramework(t, config)
	err := fw.Setup(config)
	require.NoError(t, err, "failed to setup test framework")
	defer fw.Cleanup()

	sftpClient, sshConn, err := fw.ConnectSFTP("testuser", "testuserpassword")
	require.NoError(t, err, "failed to connect as testuser")
	defer sshConn.Close()
	defer sftpClient.Close()

	// Create a 1MB file
	t.Run("Upload1MB", func(t *testing.T) {
		size := 1024 * 1024 // 1MB
		testData := bytes.Repeat([]byte("A"), size)

		file, err := sftpClient.Create("/large_file.bin")
		require.NoError(t, err)
		n, err := file.Write(testData)
		require.NoError(t, err)
		require.Equal(t, size, n)
		file.Close()

		// Verify file size
		info, err := sftpClient.Stat("/large_file.bin")
		require.NoError(t, err)
		require.Equal(t, int64(size), info.Size())

		// Verify content
		readFile, err := sftpClient.Open("/large_file.bin")
		require.NoError(t, err)
		content, err := io.ReadAll(readFile)
		require.NoError(t, err)
		readFile.Close()
		require.Equal(t, testData, content)

		// Clean up
		err = sftpClient.Remove("/large_file.bin")
		require.NoError(t, err)
	})
}

// TestStatOperations tests Stat and Lstat operations
func TestStatOperations(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test in short mode")
	}

	config := DefaultTestConfig()
	config.EnableDebug = testing.Verbose()

	fw := NewSftpTestFramework(t, config)
	err := fw.Setup(config)
	require.NoError(t, err, "failed to setup test framework")
	defer fw.Cleanup()

	sftpClient, sshConn, err := fw.ConnectSFTP("testuser", "testuserpassword")
	require.NoError(t, err, "failed to connect as testuser")
	defer sshConn.Close()
	defer sftpClient.Close()

	// Create a test file
	testContent := []byte("stat test content")
	file, err := sftpClient.Create("/stat_test.txt")
	require.NoError(t, err)
	_, err = file.Write(testContent)
	require.NoError(t, err)
	file.Close()

	t.Run("StatFile", func(t *testing.T) {
		info, err := sftpClient.Stat("/stat_test.txt")
		require.NoError(t, err)
		require.Equal(t, "stat_test.txt", info.Name())
		require.Equal(t, int64(len(testContent)), info.Size())
		require.False(t, info.IsDir())
	})

	t.Run("StatDirectory", func(t *testing.T) {
		err := sftpClient.Mkdir("/stat_dir")
		require.NoError(t, err)

		info, err := sftpClient.Stat("/stat_dir")
		require.NoError(t, err)
		require.Equal(t, "stat_dir", info.Name())
		require.True(t, info.IsDir())

		// Clean up
		err = sftpClient.RemoveDirectory("/stat_dir")
		require.NoError(t, err)
	})

	t.Run("StatRoot", func(t *testing.T) {
		// Should be able to stat "/" which maps to user's home directory
		info, err := sftpClient.Stat("/")
		require.NoError(t, err, "should be able to stat root (home) directory")
		require.True(t, info.IsDir(), "root should be a directory")
	})

	// Clean up
	err = sftpClient.Remove("/stat_test.txt")
	require.NoError(t, err)
}

// TestWalk tests walking directory trees
func TestWalk(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test in short mode")
	}

	config := DefaultTestConfig()
	config.EnableDebug = testing.Verbose()

	fw := NewSftpTestFramework(t, config)
	err := fw.Setup(config)
	require.NoError(t, err, "failed to setup test framework")
	defer fw.Cleanup()

	sftpClient, sshConn, err := fw.ConnectSFTP("testuser", "testuserpassword")
	require.NoError(t, err, "failed to connect as testuser")
	defer sshConn.Close()
	defer sftpClient.Close()

	// Create directory structure
	err = sftpClient.MkdirAll("/walk/a/b")
	require.NoError(t, err)
	err = sftpClient.MkdirAll("/walk/c")
	require.NoError(t, err)

	// Create files
	for _, p := range []string{"/walk/file1.txt", "/walk/a/file2.txt", "/walk/a/b/file3.txt", "/walk/c/file4.txt"} {
		file, err := sftpClient.Create(p)
		require.NoError(t, err)
		file.Write([]byte("test"))
		file.Close()
	}

	t.Run("WalkEntireTree", func(t *testing.T) {
		var paths []string
		walker := sftpClient.Walk("/walk")
		for walker.Step() {
			if walker.Err() != nil {
				continue
			}
			paths = append(paths, walker.Path())
		}

		// Should find all directories and files
		require.Contains(t, paths, "/walk")
		require.Contains(t, paths, "/walk/a")
		require.Contains(t, paths, "/walk/a/b")
		require.Contains(t, paths, "/walk/c")
	})

	// Clean up
	for _, p := range []string{"/walk/file1.txt", "/walk/a/file2.txt", "/walk/a/b/file3.txt", "/walk/c/file4.txt"} {
		require.NoError(t, sftpClient.Remove(p))
	}
	for _, p := range []string{"/walk/a/b", "/walk/a", "/walk/c", "/walk"} {
		require.NoError(t, sftpClient.RemoveDirectory(p))
	}
}

// TestCurrentWorkingDirectory tests that Getwd and Chdir work correctly
func TestCurrentWorkingDirectory(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test in short mode")
	}

	config := DefaultTestConfig()
	config.EnableDebug = testing.Verbose()

	fw := NewSftpTestFramework(t, config)
	err := fw.Setup(config)
	require.NoError(t, err, "failed to setup test framework")
	defer fw.Cleanup()

	sftpClient, sshConn, err := fw.ConnectSFTP("testuser", "testuserpassword")
	require.NoError(t, err, "failed to connect as testuser")
	defer sshConn.Close()
	defer sftpClient.Close()

	// Create test directory
	err = sftpClient.Mkdir("/cwd_test")
	require.NoError(t, err)

	t.Run("GetCurrentDir", func(t *testing.T) {
		cwd, err := sftpClient.Getwd()
		require.NoError(t, err)
		// The initial working directory should be the user's home directory
		// which from the user's perspective is "/"
		require.Equal(t, "/", cwd, "initial working directory should be the virtual root")
	})

	t.Run("ChangeAndCreate", func(t *testing.T) {
		// Create file in subdirectory using relative path after chdir
		// Note: pkg/sftp doesn't support Chdir, so we test using absolute paths
		file, err := sftpClient.Create("/cwd_test/relative_file.txt")
		require.NoError(t, err)
		file.Write([]byte("test"))
		file.Close()

		// Verify using absolute path
		_, err = sftpClient.Stat("/cwd_test/relative_file.txt")
		require.NoError(t, err)

		// Clean up
		sftpClient.Remove("/cwd_test/relative_file.txt")
	})

	// Clean up
	err = sftpClient.RemoveDirectory("/cwd_test")
	require.NoError(t, err)
}

// TestPathEdgeCases tests various edge cases in path handling
func TestPathEdgeCases(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test in short mode")
	}

	config := DefaultTestConfig()
	config.EnableDebug = testing.Verbose()

	fw := NewSftpTestFramework(t, config)
	err := fw.Setup(config)
	require.NoError(t, err, "failed to setup test framework")
	defer fw.Cleanup()

	sftpClient, sshConn, err := fw.ConnectSFTP("testuser", "testuserpassword")
	require.NoError(t, err, "failed to connect as testuser")
	defer sshConn.Close()
	defer sftpClient.Close()

	t.Run("PathWithDotDot", func(t *testing.T) {
		// Create directory structure
		err := sftpClient.MkdirAll("/edge/subdir")
		require.NoError(t, err)

		// Create file using path with ..
		file, err := sftpClient.Create("/edge/subdir/../file.txt")
		require.NoError(t, err)
		file.Write([]byte("test"))
		file.Close()

		// Verify file was created in /edge
		_, err = sftpClient.Stat("/edge/file.txt")
		require.NoError(t, err, "file should be created in parent directory")

		// Clean up
		sftpClient.Remove("/edge/file.txt")
		sftpClient.RemoveDirectory("/edge/subdir")
		sftpClient.RemoveDirectory("/edge")
	})

	t.Run("PathWithTrailingSlash", func(t *testing.T) {
		err := sftpClient.Mkdir("/trailing")
		require.NoError(t, err)

		// Stat with trailing slash
		info, err := sftpClient.Stat("/trailing/")
		require.NoError(t, err)
		require.True(t, info.IsDir())

		// Clean up
		sftpClient.RemoveDirectory("/trailing")
	})

	t.Run("CreateFileAtRootPath", func(t *testing.T) {
		// This is the exact scenario from issue #7470
		// User with HomeDir="/sftp/testuser" uploads to "/"
		file, err := sftpClient.Create("/issue7470.txt")
		require.NoError(t, err, "should be able to create file at / (issue #7470)")
		file.Write([]byte("This tests the fix for issue #7470"))
		file.Close()

		// Verify
		_, err = sftpClient.Stat("/issue7470.txt")
		require.NoError(t, err)

		// Clean up
		sftpClient.Remove("/issue7470.txt")
	})

	// Security test: path traversal attacks should be blocked
	t.Run("PathTraversalPrevention", func(t *testing.T) {
		// User's HomeDir is "/sftp/testuser"
		// Attempting to escape via "../.." should NOT create files outside home directory

		// First, create a valid file to ensure we can write
		validFile, err := sftpClient.Create("/valid.txt")
		require.NoError(t, err)
		validFile.Write([]byte("valid"))
		validFile.Close()

		// Try various path traversal attempts
		// These should either:
		// 1. Be blocked (error returned), OR
		// 2. Be safely resolved to stay within home directory

		traversalPaths := []string{
			"/../escape.txt",
			"/../../escape.txt",
			"/../../../escape.txt",
			"/subdir/../../escape.txt",
			"/./../../escape.txt",
		}

		for _, traversalPath := range traversalPaths {
			t.Run(traversalPath, func(t *testing.T) {
				// Note: The pkg/sftp client sanitizes paths locally before sending them to the server.
				// So "/../escape.txt" becomes "/escape.txt" on the wire.
				// Therefore, we cannot trigger the server-side path traversal block with this client.
				// Instead, we verify that the file is created successfully within the jail (contained).
				// The server-side protection logic is verified in unit tests (sftpd/sftp_server_test.go).

				file, err := sftpClient.Create(traversalPath)
				require.NoError(t, err, "creation should succeed because client sanitizes path")
				file.Close()

				// Clean up
				err = sftpClient.Remove(traversalPath)
				require.NoError(t, err)
			})
		}

		// Clean up
		sftpClient.Remove("/valid.txt")
	})
}

// TestFileContent tests reading and writing file content correctly
func TestFileContent(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test in short mode")
	}

	config := DefaultTestConfig()
	config.EnableDebug = testing.Verbose()

	fw := NewSftpTestFramework(t, config)
	err := fw.Setup(config)
	require.NoError(t, err, "failed to setup test framework")
	defer fw.Cleanup()

	sftpClient, sshConn, err := fw.ConnectSFTP("testuser", "testuserpassword")
	require.NoError(t, err, "failed to connect as testuser")
	defer sshConn.Close()
	defer sftpClient.Close()

	t.Run("BinaryContent", func(t *testing.T) {
		// Create binary data with all byte values
		data := make([]byte, 256)
		for i := 0; i < 256; i++ {
			data[i] = byte(i)
		}

		file, err := sftpClient.Create("/binary.bin")
		require.NoError(t, err)
		n, err := file.Write(data)
		require.NoError(t, err)
		require.Equal(t, 256, n)
		file.Close()

		// Read back
		readFile, err := sftpClient.Open("/binary.bin")
		require.NoError(t, err)
		content, err := io.ReadAll(readFile)
		require.NoError(t, err)
		readFile.Close()

		require.Equal(t, data, content, "binary content should match")

		// Clean up
		sftpClient.Remove("/binary.bin")
	})

	t.Run("WriteAtOffsetKeepsExistingBytes", func(t *testing.T) {
		file, err := sftpClient.Create("/resume.txt")
		require.NoError(t, err)
		_, err = file.Write([]byte("hello world"))
		require.NoError(t, err)
		require.NoError(t, file.Close())

		// Reopen without O_TRUNC and write past the start, as a resumed upload does
		file, err = sftpClient.OpenFile("/resume.txt", os.O_WRONLY)
		require.NoError(t, err)
		_, err = file.WriteAt([]byte("WORLD!"), 6)
		require.NoError(t, err)
		require.NoError(t, file.Close())

		readFile, err := sftpClient.Open("/resume.txt")
		require.NoError(t, err)
		content, err := io.ReadAll(readFile)
		require.NoError(t, err)
		readFile.Close()

		require.Equal(t, "hello WORLD!", string(content))

		// Clean up
		sftpClient.Remove("/resume.txt")
	})

	t.Run("EmptyFile", func(t *testing.T) {
		file, err := sftpClient.Create("/empty.txt")
		require.NoError(t, err)
		file.Close()

		info, err := sftpClient.Stat("/empty.txt")
		require.NoError(t, err)
		require.Equal(t, int64(0), info.Size())

		// Clean up
		sftpClient.Remove("/empty.txt")
	})

	t.Run("UnicodeFilename", func(t *testing.T) {
		filename := "/文件名.txt"
		content := []byte("Unicode content: 你好世界")

		file, err := sftpClient.Create(filename)
		require.NoError(t, err)
		file.Write(content)
		file.Close()

		// Read back
		readFile, err := sftpClient.Open(filename)
		require.NoError(t, err)
		readContent, err := io.ReadAll(readFile)
		require.NoError(t, err)
		readFile.Close()

		require.Equal(t, content, readContent)

		// Verify in listing
		files, err := sftpClient.ReadDir("/")
		require.NoError(t, err)
		found := false
		for _, f := range files {
			if f.Name() == path.Base(filename) {
				found = true
				break
			}
		}
		require.True(t, found, "should find unicode filename in listing")

		// Clean up
		sftpClient.Remove(filename)
	})
}