Skip to content

Modern Docker Management, Designed for Everyone

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.go
index 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, r
envLoader := 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, composeContent
return 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, pr
return 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, pr
return 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 string
tempDir string
diff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.go
index 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.go
index 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]any
if 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}, nil
case 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, nil
default:
- 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 directory
diff --git a/backend/pkg/projects/includes_test.go b/backend/pkg/projects/includes_test.go
index 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 perms
origFilePerm := pkgutils.FilePerm