Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: block unsafe compose include file reads (#2630)
Kyle Mendellb6cbffabf61d
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.goindex bc1578c53..e83d1ec5b 100644--- a/backend/internal/services/project_service.go+++ b/backend/internal/services/project_service.go@@ -1039,16 +1039,16 @@ func (s *ProjectService) GetProjectFileContent(ctx context.Context, projectID, renvLoader := projects.NewEnvLoader(projectsDirectory, filepath.Dir(composeFile), utils.BoolOrDefault(cfg.AutoInjectEnv.Value, false))envMap, _, _ := envLoader.LoadEnvironment(ctx)- includes, parseErr := projects.ParseIncludes(composeFile, envMap, true)+ includes, parseErr := projects.ParseIncludes(composeFile, envMap, false)if parseErr == nil {for _, inc := range includes {- if inc.RelativePath == relativePath {- return project.IncludeFile{- Path: inc.Path,- RelativePath: inc.RelativePath,- Content: inc.Content,- }, nil+ if inc.RelativePath != relativePath {+ continue+ }+ if !projects.IsSafeSubdirectory(proj.Path, inc.Path) {+ return project.IncludeFile{}, &common.ProjectFileForbiddenError{Err: fmt.Errorf("file path is outside project directory")}}+ return readProjectIncludeFileContentInternal(proj.Path, inc)}}}@@ -1098,6 +1098,60 @@ func (s *ProjectService) GetProjectFileContent(ctx context.Context, projectID, r}, nil}+func readProjectIncludeFileContentInternal(projectPath string, inc projects.IncludeFile) (project.IncludeFile, error) {+ validatedPath, err := projects.ValidateIncludePathForWrite(projectPath, inc.Path)+ if err != nil {+ return project.IncludeFile{}, &common.ProjectFileForbiddenError{Err: fmt.Errorf("file path is outside project directory")}+ }++ resolvedProjectPath, err := filepath.EvalSymlinks(projectPath)+ if err != nil {+ return project.IncludeFile{}, fmt.Errorf("failed to resolve project path: %w", err)+ }+ resolvedPath, err := filepath.EvalSymlinks(validatedPath)+ if err != nil {+ if os.IsNotExist(err) {+ return project.IncludeFile{+ Path: validatedPath,+ RelativePath: inc.RelativePath,+ Content: "# This file will be created when you save changes\nservices:\n",+ }, nil+ }+ return project.IncludeFile{}, fmt.Errorf("failed to resolve include file: %w", err)+ }+ if !projects.IsSafeSubdirectory(resolvedProjectPath, resolvedPath) {+ return project.IncludeFile{}, &common.ProjectFileForbiddenError{Err: fmt.Errorf("file path is outside project directory")}+ }++ info, err := os.Stat(resolvedPath)+ if err != nil {+ if os.IsNotExist(err) {+ return project.IncludeFile{}, &common.ProjectFileNotFoundError{}+ }+ return project.IncludeFile{}, fmt.Errorf("failed to stat include file: %w", err)+ }+ if info.IsDir() {+ return project.IncludeFile{}, &common.ProjectFileBadRequestError{Err: fmt.Errorf("path refers to a directory")}+ }++ content, err := os.ReadFile(resolvedPath)+ if err != nil {+ if os.IsNotExist(err) {+ return project.IncludeFile{}, &common.ProjectFileNotFoundError{}+ }+ return project.IncludeFile{}, fmt.Errorf("failed to read include file: %w", err)+ }+ if projects.IsBinaryProjectFileContent(content) {+ return project.IncludeFile{}, &common.ProjectFileBadRequestError{Err: fmt.Errorf("binary files are not supported")}+ }++ return project.IncludeFile{+ Path: resolvedPath,+ RelativePath: inc.RelativePath,+ Content: string(content),+ }, nil+}+func (s *ProjectService) enrichWithIncludeFiles(ctx context.Context, composeFile string, resp *project.Details) {if strings.TrimSpace(composeFile) == "" {return@@ -1922,6 +1976,12 @@ func (s *ProjectService) CreateProject(ctx context.Context, name, composeContentreturn nil, fmt.Errorf("failed to create project: %w", err)}+ if err := s.validateComposeContentForUpdate(ctx, projectsDirectory, projectPath, name, composeContent, envContent); err != nil {+ _ = s.db.WithContext(ctx).Delete(proj).Error+ _ = os.RemoveAll(projectPath)+ return nil, fmt.Errorf("invalid compose file: %w", err)+ }+if err := projects.SaveOrUpdateProjectFiles(projectsDirectory, projectPath, composeContent, envContent); err != nil {// Best-effort cleanup to restore pre-transaction behavior._ = s.db.WithContext(ctx).Delete(proj).Error@@ -2926,6 +2986,10 @@ func (s *ProjectService) validateComposeContentForUpdate(ctx context.Context, prreturn envErr}+ if err := validateComposeIncludePathsForProjectInternal(projectPath, composeContent, fullEnvMap); err != nil {+ return err+ }+validationProjectName := normalizeComposeProjectName(projectName)cfg := composetypes.ConfigDetails{Version: api.ComposeVersion,@@ -2952,6 +3016,19 @@ func (s *ProjectService) validateComposeContentForUpdate(ctx context.Context, prreturn err}+func validateComposeIncludePathsForProjectInternal(projectPath, composeContent string, envMap projects.EnvMap) error {+ includes, err := projects.ParseIncludesFromContent(filepath.Join(projectPath, "compose.yaml"), []byte(composeContent), envMap, false)+ if err != nil {+ return err+ }+ for _, inc := range includes {+ if _, err := projects.ValidateIncludePathForWrite(projectPath, inc.Path); err != nil {+ return fmt.Errorf("include path %q is outside project directory: %w", inc.RelativePath, err)+ }+ }+ return nil+}+type missingIncludeStubResourceLoaderInternal struct {projectPath stringtempDir stringdiff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.goindex 63a6cc79f..45bff7279 100644--- a/backend/internal/services/project_service_test.go+++ b/backend/internal/services/project_service_test.go@@ -1213,6 +1213,215 @@ services:assert.NoFileExists(t, filepath.Join(projectPath, "compose.yaml"))}+func TestProjectService_CreateProject_RejectsExternalInclude(t *testing.T) {+ db := setupProjectTestDB(t)+ ctx := context.Background()++ projectsDir := t.TempDir()+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)++ settingsService, err := NewSettingsService(ctx, db)+ require.NoError(t, err)++ eventService := NewEventService(db, nil, nil)+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())+ require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "metadata.yaml"), []byte("services: {}\n"), 0o644))++ compose := `include:+ - ../metadata.yaml+services:+ app:+ image: nginx:alpine+`++ project, err := svc.CreateProject(ctx, "evil", compose, nil, models.User{+ BaseModel: models.BaseModel{ID: "u1"},+ Username: "tester",+ })+ require.Error(t, err)+ assert.Nil(t, project)+ assert.Contains(t, err.Error(), "invalid compose file")+ assert.NoDirExists(t, filepath.Join(projectsDir, "evil"))+ assert.FileExists(t, filepath.Join(projectsDir, "metadata.yaml"))++ var count int64+ require.NoError(t, db.Model(&models.Project{}).Where("name = ?", "evil").Count(&count).Error)+ assert.Zero(t, count)+}++func TestProjectService_CreateProject_RejectsArrayPathInclude(t *testing.T) {+ db := setupProjectTestDB(t)+ ctx := context.Background()++ projectsDir := t.TempDir()+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)++ settingsService, err := NewSettingsService(ctx, db)+ require.NoError(t, err)++ eventService := NewEventService(db, nil, nil)+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())+ require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "metadata.yaml"), []byte("services: {}\n"), 0o644))++ compose := `include:+ - path:+ - ./local.yaml+ - ../metadata.yaml+services:+ app:+ image: nginx:alpine+`++ project, err := svc.CreateProject(ctx, "evil-array", compose, nil, models.User{+ BaseModel: models.BaseModel{ID: "u1"},+ Username: "tester",+ })+ require.Error(t, err)+ assert.Nil(t, project)+ assert.Contains(t, err.Error(), "invalid compose file")+ assert.NoDirExists(t, filepath.Join(projectsDir, "evil-array"))+ assert.FileExists(t, filepath.Join(projectsDir, "metadata.yaml"))++ var count int64+ require.NoError(t, db.Model(&models.Project{}).Where("name = ?", "evil-array").Count(&count).Error)+ assert.Zero(t, count)+}++func TestProjectService_GetProjectFileContent_RejectsExternalInclude(t *testing.T) {+ db := setupProjectTestDB(t)+ ctx := context.Background()++ projectsDir := t.TempDir()+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)++ settingsService, err := NewSettingsService(ctx, db)+ require.NoError(t, err)++ eventService := NewEventService(db, nil, nil)+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())++ dirName := "include-read"+ projectPath := filepath.Join(projectsDir, dirName)+ require.NoError(t, os.MkdirAll(projectPath, 0o755))+ require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "metadata.yaml"), []byte("services: {}\n"), 0o644))++ project := &models.Project{+ BaseModel: models.BaseModel{ID: "proj-external-include-read"},+ Name: "include-read",+ DirName: &dirName,+ Path: projectPath,+ Status: models.ProjectStatusStopped,+ }+ require.NoError(t, db.Create(project).Error)++ compose := `include:+ - ../metadata.yaml+services:+ app:+ image: nginx:alpine+`+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(compose), 0o644))++ includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "../metadata.yaml")+ require.Error(t, err)+ assert.Empty(t, includeFile)++ var forbiddenErr *common.ProjectFileForbiddenError+ assert.ErrorAs(t, err, &forbiddenErr)+}++func TestProjectService_GetProjectFileContent_RejectsSymlinkInclude(t *testing.T) {+ db := setupProjectTestDB(t)+ ctx := context.Background()++ projectsDir := t.TempDir()+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)++ settingsService, err := NewSettingsService(ctx, db)+ require.NoError(t, err)++ eventService := NewEventService(db, nil, nil)+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())++ dirName := "include-symlink"+ projectPath := filepath.Join(projectsDir, dirName)+ require.NoError(t, os.MkdirAll(projectPath, 0o755))++ outsidePath := filepath.Join(t.TempDir(), "outside.yaml")+ require.NoError(t, os.WriteFile(outsidePath, []byte("services: {}\n"), 0o644))+ require.NoError(t, os.Symlink(outsidePath, filepath.Join(projectPath, "evil-link")))++ project := &models.Project{+ BaseModel: models.BaseModel{ID: "proj-symlink-include-read"},+ Name: "include-symlink",+ DirName: &dirName,+ Path: projectPath,+ Status: models.ProjectStatusStopped,+ }+ require.NoError(t, db.Create(project).Error)++ compose := `include:+ - ./evil-link+services:+ app:+ image: nginx:alpine+`+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(compose), 0o644))++ includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "evil-link")+ require.Error(t, err)+ assert.Empty(t, includeFile)++ var forbiddenErr *common.ProjectFileForbiddenError+ assert.ErrorAs(t, err, &forbiddenErr)+}++func TestProjectService_GetProjectFileContent_RejectsIntermediateSymlinkInclude(t *testing.T) {+ db := setupProjectTestDB(t)+ ctx := context.Background()++ projectsDir := t.TempDir()+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)++ settingsService, err := NewSettingsService(ctx, db)+ require.NoError(t, err)++ eventService := NewEventService(db, nil, nil)+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil, config.Load())++ dirName := "include-intermediate-symlink"+ projectPath := filepath.Join(projectsDir, dirName)+ require.NoError(t, os.MkdirAll(projectPath, 0o755))++ outsideDir := t.TempDir()+ require.NoError(t, os.WriteFile(filepath.Join(outsideDir, "secret.yaml"), []byte("services: {}\n"), 0o644))+ require.NoError(t, os.Symlink(outsideDir, filepath.Join(projectPath, "subdir")))++ project := &models.Project{+ BaseModel: models.BaseModel{ID: "proj-intermediate-symlink-include-read"},+ Name: "include-intermediate-symlink",+ DirName: &dirName,+ Path: projectPath,+ Status: models.ProjectStatusStopped,+ }+ require.NoError(t, db.Create(project).Error)++ compose := `include:+ - ./subdir/secret.yaml+services:+ app:+ image: nginx:alpine+`+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(compose), 0o644))++ includeFile, err := svc.GetProjectFileContent(ctx, project.ID, "subdir/secret.yaml")+ require.Error(t, err)+ assert.Empty(t, includeFile)++ var forbiddenErr *common.ProjectFileForbiddenError+ assert.ErrorAs(t, err, &forbiddenErr)+}+func TestProjectService_UpdateProject_UsesExistingEnvFileDuringComposeValidation(t *testing.T) {db := setupProjectTestDB(t)ctx := context.Background()diff --git a/backend/pkg/projects/includes.go b/backend/pkg/projects/includes.goindex 967cf14b8..d1bbb6b47 100644--- a/backend/pkg/projects/includes.go+++ b/backend/pkg/projects/includes.go@@ -22,10 +22,12 @@ func expandEnvVarsInternal(s string, envMap EnvMap) string {}// Security Model for Include Files:-// - READ: Docker Compose allows include files from anywhere (parent dirs, absolute paths, etc.)-// We allow reading from any path to maintain compatibility with standard Docker Compose behavior-// - WRITE/DELETE: Restricted to files within the project directory only for security-// This prevents malicious users from modifying files outside the project scope+// - READ: Docker Compose's spec allows include files from anywhere (parent dirs,+// absolute paths). ParseIncludes does NOT enforce containment; it returns whatever+// the compose file points at. Callers must validate containment and symlinks before+// reading include content or returning inc.Content to users.+// - WRITE/DELETE: Restricted to files within the project directory only for security.+// Always go through ValidateIncludePathForWrite or WriteIncludeFile.type IncludeFile struct {Path string `json:"path"`@@ -41,6 +43,11 @@ func ParseIncludes(composeFilePath string, envMap EnvMap, includeContent bool) (return nil, fmt.Errorf("failed to read compose file: %w", err)}+ return ParseIncludesFromContent(composeFilePath, content, envMap, includeContent)+}++// ParseIncludesFromContent extracts include directives from compose content using composeFilePath as the base path.+func ParseIncludesFromContent(composeFilePath string, content []byte, envMap EnvMap, includeContent bool) ([]IncludeFile, error) {var composeData map[string]anyif err := yaml.Unmarshal(content, &composeData); err != nil {return nil, fmt.Errorf("failed to parse compose file: %w", err)@@ -58,33 +65,77 @@ func ParseIncludes(composeFilePath string, envMap EnvMap, includeContent bool) (switch v := includes.(type) {case []any:for _, item := range v {- if include, err := parseIncludeItemInternal(item, composeDir, envMap, includeContent); err == nil {- includeFiles = append(includeFiles, include)+ incs, err := parseIncludeItemInternal(item, composeDir, envMap, includeContent)+ if err != nil {+ return nil, err}+ includeFiles = append(includeFiles, incs...)}case string:- if include, err := parseIncludeItemInternal(v, composeDir, envMap, includeContent); err == nil {- includeFiles = append(includeFiles, include)+ incs, err := parseIncludeItemInternal(v, composeDir, envMap, includeContent)+ if err != nil {+ return nil, err}+ includeFiles = append(includeFiles, incs...)+ case nil:+ // `include:` key present but null (e.g. `include: ~`) — treat as empty.+ return []IncludeFile{}, nil+ default:+ return nil, fmt.Errorf("invalid include type")}return includeFiles, nil}-func parseIncludeItemInternal(item any, baseDir string, envMap EnvMap, includeContent bool) (IncludeFile, error) {- var includePath string+func parseIncludeItemInternal(item any, baseDir string, envMap EnvMap, includeContent bool) ([]IncludeFile, error) {+ includePaths, err := extractIncludePathsInternal(item)+ if err != nil {+ return nil, err+ }+ results := make([]IncludeFile, 0, len(includePaths))+ for _, includePath := range includePaths {+ inc, err := resolveIncludeFileInternal(includePath, baseDir, envMap, includeContent)+ if err != nil {+ return nil, err+ }+ results = append(results, inc)+ }+ return results, nil+}++func extractIncludePathsInternal(item any) ([]string, error) {switch v := item.(type) {case string:- includePath = v+ return []string{v}, nilcase map[string]any:- if path, ok := v["path"].(string); ok {- includePath = path+ return extractIncludePathsFromMapInternal(v)+ default:+ return nil, fmt.Errorf("invalid include item type")+ }+}++func extractIncludePathsFromMapInternal(v map[string]any) ([]string, error) {+ switch p := v["path"].(type) {+ case string:+ return []string{p}, nil+ case []any:+ // Docker Compose allows `path: [./base.yaml, ./override.yaml]` for multi-file overrides.+ paths := make([]string, 0, len(p))+ for _, entry := range p {+ s, ok := entry.(string)+ if !ok {+ return nil, fmt.Errorf("invalid include path entry: expected string, got %T", entry)+ }+ paths = append(paths, s)}+ return paths, nildefault:- return IncludeFile{}, fmt.Errorf("invalid include item type")+ return nil, fmt.Errorf("invalid include path type: %T", v["path"])}+}+func resolveIncludeFileInternal(includePath, baseDir string, envMap EnvMap, includeContent bool) (IncludeFile, error) {if includePath == "" {return IncludeFile{}, fmt.Errorf("empty include path")}@@ -100,19 +151,9 @@ func parseIncludeItemInternal(item any, baseDir string, envMap EnvMap, includeCo}fullPath = filepath.Clean(fullPath)- var content string- if includeContent {- fileContent, err := os.ReadFile(fullPath)- if err != nil {- if errors.Is(err, os.ErrNotExist) {- // File doesn't exist yet - return empty content so it can be created- content = "# This file will be created when you save changes\nservices:\n"- } else {- return IncludeFile{}, fmt.Errorf("failed to read include file %s: %w", includePath, err)- }- } else {- content = string(fileContent)- }+ content, err := readIncludeContentInternal(fullPath, includePath, includeContent)+ if err != nil {+ return IncludeFile{}, err}relativePath := includePath@@ -133,6 +174,21 @@ func parseIncludeItemInternal(item any, baseDir string, envMap EnvMap, includeCo}, nil}+func readIncludeContentInternal(fullPath, includePath string, includeContent bool) (string, error) {+ if !includeContent {+ return "", nil+ }+ fileContent, err := os.ReadFile(fullPath)+ if err == nil {+ return string(fileContent), nil+ }+ if errors.Is(err, os.ErrNotExist) {+ // File doesn't exist yet - return empty content so it can be created+ return "# This file will be created when you save changes\nservices:\n", nil+ }+ return "", fmt.Errorf("failed to read include file %s: %w", includePath, err)+}+// ValidateIncludePathForWrite ensures the include path is safe for write operations// Returns the validated absolute path to prevent recomputation after validation// Only allows writing within the project directorydiff --git a/backend/pkg/projects/includes_test.go b/backend/pkg/projects/includes_test.goindex ab4d65fcd..c2cdb499b 100644--- a/backend/pkg/projects/includes_test.go+++ b/backend/pkg/projects/includes_test.go@@ -39,6 +39,32 @@ func TestParseIncludes_NormalizesRelativePaths(t *testing.T) {}}+func TestParseIncludes_ExpandsArrayPathForm(t *testing.T) {+ t.Parallel()++ projectDir := t.TempDir()+ composePath := filepath.Join(projectDir, "compose.yaml")++ requireNoError := func(err error) {+ t.Helper()+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ }++ requireNoError(os.WriteFile(composePath, []byte("include:\n - path:\n - ./base.yaml\n - ./override.yaml\n"), 0o600))++ includes, err := ParseIncludes(composePath, nil, false)+ requireNoError(err)++ if len(includes) != 2 {+ t.Fatalf("expected 2 includes, got %d", len(includes))+ }+ if includes[0].RelativePath != "base.yaml" || includes[1].RelativePath != "override.yaml" {+ t.Fatalf("unexpected relative paths: %q, %q", includes[0].RelativePath, includes[1].RelativePath)+ }+}+func TestWriteIncludeFilePermissions(t *testing.T) {// Save original permsorigFilePerm := pkgutils.FilePerm