Skip to content

Modern Docker Management, Designed for Everyone

refactor: unify project, env, and template file writing logic (#725)

Kyle Mendell8e42f4af3741
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index 5ae01c6c1..13ed34cf8 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -538,7 +538,7 @@ func (s *ProjectService) CreateProject(ctx context.Context, name, composeContent
}
basePath := filepath.Join(projectsDirectory, sanitized)
- projectPath, folderName, err := fs.CreateUniqueDir(basePath, name, 0755)
+ projectPath, folderName, err := fs.CreateUniqueDir(projectsDirectory, basePath, name, 0755)
if err != nil {
return nil, fmt.Errorf("failed to create project directory: %w", err)
}
@@ -556,7 +556,7 @@ func (s *ProjectService) CreateProject(ctx context.Context, name, composeContent
return nil, fmt.Errorf("failed to create project: %w", err)
}
- if err := fs.SaveOrUpdateProjectFiles(projectPath, composeContent, envContent); err != nil {
+ if err := fs.SaveOrUpdateProjectFiles(projectsDirectory, projectPath, composeContent, envContent); err != nil {
s.db.WithContext(ctx).Delete(proj)
return nil, fmt.Errorf("failed to save project files: %w", err)
}
@@ -719,6 +719,12 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, na
return nil, fmt.Errorf("failed to get project: %w", err)
}
+ // Get projects directory for security validation
+ projectsDirectory, err := fs.GetProjectsDirectory(ctx, s.settingsService.GetStringSetting(ctx, "projectsDirectory", "data/projects"))
+ if err != nil {
+ return nil, fmt.Errorf("failed to get projects directory: %w", err)
+ }
+
if name != nil {
if newName := strings.TrimSpace(*name); newName != "" && proj.Name != newName {
proj.Name = newName
@@ -727,7 +733,7 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, na
switch {
case composeContent != nil:
- if err := fs.SaveOrUpdateProjectFiles(proj.Path, *composeContent, envContent); err != nil {
+ if err := fs.SaveOrUpdateProjectFiles(projectsDirectory, proj.Path, *composeContent, envContent); err != nil {
return nil, fmt.Errorf("failed to save project files: %w", err)
}
case envContent != nil:
@@ -737,8 +743,8 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, na
return nil, fmt.Errorf("failed to remove env file: %w", err)
}
} else {
- if err := os.WriteFile(envPath, []byte(*envContent), 0644); err != nil {
- return nil, fmt.Errorf("failed to update env file: %w", err)
+ if err := fs.WriteEnvFile(projectsDirectory, proj.Path, *envContent); err != nil {
+ return nil, err
}
}
}
diff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.go
index 673e74030..8259cd53d 100644
--- a/backend/internal/services/template_service.go
+++ b/backend/internal/services/template_service.go
@@ -367,16 +367,8 @@ func (s *TemplateService) GetComposeTemplate() string {
func (s *TemplateService) SaveComposeTemplate(content string) error {
templateDir := filepath.Join("data", "templates")
- if err := os.MkdirAll(templateDir, 0755); err != nil {
- return fmt.Errorf("failed to create template directory: %w", err)
- }
-
composePath := filepath.Join(templateDir, ".compose.template")
- if err := os.WriteFile(composePath, []byte(content), 0644); err != nil {
- return fmt.Errorf("failed to save compose template: %w", err)
- }
-
- return nil
+ return appfs.WriteTemplateFile(composePath, content)
}
func (s *TemplateService) GetEnvTemplate() string {
@@ -391,16 +383,8 @@ func (s *TemplateService) GetEnvTemplate() string {
func (s *TemplateService) SaveEnvTemplate(content string) error {
templateDir := filepath.Join("data", "templates")
- if err := os.MkdirAll(templateDir, 0755); err != nil {
- return fmt.Errorf("failed to create template directory: %w", err)
- }
-
envPath := filepath.Join(templateDir, ".env.template")
- if err := os.WriteFile(envPath, []byte(content), 0644); err != nil {
- return fmt.Errorf("failed to save env template: %w", err)
- }
-
- return nil
+ return appfs.WriteTemplateFile(envPath, content)
}
func (s *TemplateService) GetRegistries(ctx context.Context) ([]models.TemplateRegistry, error) {
@@ -969,7 +953,7 @@ func (s *TemplateService) UpdateGlobalVariables(ctx context.Context, vars []dto.
builder.WriteString(fmt.Sprintf("%s=%s\n", key, value))
}
- if err := os.WriteFile(envPath, []byte(builder.String()), 0644); err != nil {
+ if err := appfs.WriteFileWithPerm(envPath, builder.String(), appfs.FilePerm); err != nil {
return fmt.Errorf("failed to write global variables file: %w", err)
}
@@ -996,7 +980,7 @@ func (s *TemplateService) ParseComposeServices(ctx context.Context, composeConte
// Create a dummy .env file to prevent env file errors
envPath := filepath.Join(tmpDir, ".env")
- if err := os.WriteFile(envPath, []byte(""), 0644); err != nil {
+ if err := appfs.WriteFileWithPerm(envPath, "", appfs.FilePerm); err != nil {
slog.WarnContext(ctx, "Failed to create dummy env file", "error", err)
}
diff --git a/backend/internal/utils/fs/fs_templates.go b/backend/internal/utils/fs/fs_templates.go
index 833a16f4b..747b393e6 100644
--- a/backend/internal/utils/fs/fs_templates.go
+++ b/backend/internal/utils/fs/fs_templates.go
@@ -68,15 +68,17 @@ func ImportedComposeDescription(dir string) string {
}
func WriteTemplateFiles(composePath, envPath, composeContent, envContent string) (*string, error) {
- if err := os.WriteFile(composePath, []byte(composeContent), 0644); err != nil {
- return nil, fmt.Errorf("failed to write compose file: %w", err)
+ if err := WriteTemplateFile(composePath, composeContent); err != nil {
+ return nil, err
}
+
envTrim := strings.TrimSpace(envContent)
if envTrim == "" {
return nil, nil
}
- if err := os.WriteFile(envPath, []byte(envContent), 0644); err != nil {
- return nil, fmt.Errorf("failed to write env file: %w", err)
+
+ if err := WriteTemplateFile(envPath, envContent); err != nil {
+ return nil, err
}
return &envContent, nil
}
@@ -92,14 +94,14 @@ func EnsureDefaultTemplates(ctx context.Context) error {
// Write default compose template if it doesn't exist
if _, err := os.Stat(composePath); os.IsNotExist(err) {
- if err := os.WriteFile(composePath, []byte(getDefaultComposeTemplate()), 0644); err != nil {
+ if err := WriteTemplateFile(composePath, getDefaultComposeTemplate()); err != nil {
return fmt.Errorf("write default compose template: %w", err)
}
}
// Write default env template if it doesn't exist
if _, err := os.Stat(envPath); os.IsNotExist(err) {
- if err := os.WriteFile(envPath, []byte(getDefaultEnvTemplate()), 0644); err != nil {
+ if err := WriteTemplateFile(envPath, getDefaultEnvTemplate()); err != nil {
return fmt.Errorf("write default env template: %w", err)
}
}
diff --git a/backend/internal/utils/fs/fs_util.go b/backend/internal/utils/fs/fs_util.go
index f17d9c8da..c3c4b065e 100644
--- a/backend/internal/utils/fs/fs_util.go
+++ b/backend/internal/utils/fs/fs_util.go
@@ -68,13 +68,50 @@ func GetTemplatesDirectory(ctx context.Context) (string, error) {
return templatesDir, nil
}
-func CreateUniqueDir(basePath, name string, perm os.FileMode) (path, folderName string, err error) {
+// CreateUniqueDir creates a unique directory within the allowed projectsRoot.
+// It validates that the created directory is always within projectsRoot.
+func CreateUniqueDir(projectsRoot, basePath, name string, perm os.FileMode) (path, folderName string, err error) {
sanitized := SanitizeProjectName(name)
+
+ // Reject empty or invalid sanitized names
+ if sanitized == "" || strings.Trim(sanitized, "_") == "" {
+ return "", "", fmt.Errorf("invalid project name: results in empty directory name")
+ }
+
+ // Get absolute path of the true projects root for validation
+ projectsRootAbs, err := filepath.Abs(projectsRoot)
+ if err != nil {
+ return "", "", fmt.Errorf("failed to resolve projects root directory: %w", err)
+ }
+ projectsRootAbs = filepath.Clean(projectsRootAbs)
+
candidate := basePath
folderName = sanitized
for counter := 1; ; counter++ {
+ // Validate candidate is within the allowed projects root
+ candidateAbs, absErr := filepath.Abs(candidate)
+ if absErr != nil {
+ return "", "", fmt.Errorf("failed to resolve candidate path: %w", absErr)
+ }
+ candidateAbs = filepath.Clean(candidateAbs)
+
+ // Security check: ensure candidate is a subdirectory of projectsRoot
+ if !IsSafeSubdirectory(projectsRootAbs, candidateAbs) {
+ return "", "", fmt.Errorf("project directory would be outside allowed projects root")
+ }
+
if mkErr := os.Mkdir(candidate, perm); mkErr == nil {
+ // Double-check after creation - paranoid validation
+ if !IsSafeSubdirectory(projectsRootAbs, candidateAbs) {
+ // Security violation detected - remove the unsafe directory
+ // We only reach here if somehow a directory was created outside the root
+ // despite pre-checks. Clean up by removing ONLY if it's actually within root.
+ if strings.HasPrefix(candidateAbs, projectsRootAbs+string(filepath.Separator)) {
+ os.Remove(candidateAbs)
+ }
+ return "", "", fmt.Errorf("created directory is outside allowed projects root")
+ }
return candidate, folderName, nil
} else if !os.IsExist(mkErr) {
return "", "", mkErr
@@ -97,28 +134,27 @@ func SanitizeProjectName(name string) string {
}, name)
}
-func SaveOrUpdateProjectFiles(projectPath, composeContent string, envContent *string) error {
- if err := os.MkdirAll(projectPath, 0755); err != nil {
- return fmt.Errorf("failed to create project directory: %w", err)
+// IsSafeSubdirectory returns true if subdir is a subdirectory of baseDir (absolute, normalized)
+func IsSafeSubdirectory(baseDir, subdir string) bool {
+ absBase, err1 := filepath.Abs(baseDir)
+ absSubdir, err2 := filepath.Abs(subdir)
+ if err1 != nil || err2 != nil {
+ return false
}
- var composePath string
- if existingComposeFile, derr := projects.DetectComposeFile(projectPath); derr == nil && existingComposeFile != "" {
- composePath = existingComposeFile
- } else {
- composePath = filepath.Join(projectPath, "compose.yaml")
- }
+ // Ensure both paths end consistently for comparison
+ absBase = filepath.Clean(absBase)
+ absSubdir = filepath.Clean(absSubdir)
- if err := os.WriteFile(composePath, []byte(composeContent), 0644); err != nil {
- return fmt.Errorf("failed to save compose file: %w", err)
+ rel, err := filepath.Rel(absBase, absSubdir)
+ if err != nil {
+ return false
}
- if envContent != nil && *envContent != "" {
- envPath := filepath.Join(projectPath, ".env")
- if err := os.WriteFile(envPath, []byte(*envContent), 0644); err != nil {
- return fmt.Errorf("failed to save env file: %w", err)
- }
- }
+ // The path must not escape the base directory
+ return !strings.HasPrefix(rel, "..") && !filepath.IsAbs(rel)
+}
- return nil
+func SaveOrUpdateProjectFiles(projectsRoot, projectPath, composeContent string, envContent *string) error {
+ return WriteProjectFiles(projectsRoot, projectPath, composeContent, envContent)
}
diff --git a/backend/internal/utils/fs/fs_writer.go b/backend/internal/utils/fs/fs_writer.go
new file mode 100644
index 000000000..079519f70
--- /dev/null
+++ b/backend/internal/utils/fs/fs_writer.go
@@ -0,0 +1,148 @@
+package fs
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+)
+
+const (
+ FilePerm = 0644
+ DirPerm = 0755
+)
+
+var composeFileCandidates = []string{
+ "compose.yaml",
+ "compose.yml",
+ "docker-compose.yaml",
+ "docker-compose.yml",
+}
+
+// detectExistingComposeFile finds an existing compose file in the directory
+func detectExistingComposeFile(dir string) string {
+ for _, filename := range composeFileCandidates {
+ fullPath := filepath.Join(dir, filename)
+ if info, err := os.Stat(fullPath); err == nil && !info.IsDir() {
+ return fullPath
+ }
+ }
+ return ""
+}
+
+// WriteComposeFile writes a compose file to the specified directory.
+// It detects existing compose file names (docker-compose.yml, compose.yaml, etc.)
+// and uses the existing name if found, otherwise defaults to compose.yaml
+// projectsRoot is the allowed root directory to prevent path traversal attacks
+func WriteComposeFile(projectsRoot, dirPath, content string) error {
+ // Security: Validate dirPath is absolute and clean to prevent path traversal
+ absPath, err := filepath.Abs(dirPath)
+ if err != nil {
+ return fmt.Errorf("failed to resolve directory path: %w", err)
+ }
+ dirPath = filepath.Clean(absPath)
+
+ // Security: Validate dirPath is within projectsRoot
+ rootAbs, err := filepath.Abs(projectsRoot)
+ if err != nil {
+ return fmt.Errorf("failed to resolve projects root: %w", err)
+ }
+ rootAbs = filepath.Clean(rootAbs)
+
+ if !IsSafeSubdirectory(rootAbs, dirPath) {
+ return fmt.Errorf("refusing to write compose file: path outside projects root")
+ }
+
+ if err := os.MkdirAll(dirPath, DirPerm); err != nil {
+ return fmt.Errorf("failed to create directory: %w", err)
+ }
+
+ var composePath string
+ if existingFile := detectExistingComposeFile(dirPath); existingFile != "" {
+ composePath = existingFile
+ } else {
+ composePath = filepath.Join(dirPath, "compose.yaml")
+ }
+
+ if err := os.WriteFile(composePath, []byte(content), FilePerm); err != nil {
+ return fmt.Errorf("failed to write compose file: %w", err)
+ }
+
+ return nil
+}
+
+// WriteEnvFile writes a .env file to the specified directory
+// projectsRoot is the allowed root directory to prevent path traversal attacks
+func WriteEnvFile(projectsRoot, dirPath, content string) error {
+ // Security: Validate dirPath is absolute and clean to prevent path traversal
+ absPath, err := filepath.Abs(dirPath)
+ if err != nil {
+ return fmt.Errorf("failed to resolve directory path: %w", err)
+ }
+ dirPath = filepath.Clean(absPath)
+
+ // Security: Validate dirPath is within projectsRoot
+ rootAbs, err := filepath.Abs(projectsRoot)
+ if err != nil {
+ return fmt.Errorf("failed to resolve projects root: %w", err)
+ }
+ rootAbs = filepath.Clean(rootAbs)
+
+ if !IsSafeSubdirectory(rootAbs, dirPath) {
+ return fmt.Errorf("refusing to write env file: path outside projects root")
+ }
+
+ if err := os.MkdirAll(dirPath, DirPerm); err != nil {
+ return fmt.Errorf("failed to create directory: %w", err)
+ }
+
+ envPath := filepath.Join(dirPath, ".env")
+ if err := os.WriteFile(envPath, []byte(content), FilePerm); err != nil {
+ return fmt.Errorf("failed to write env file: %w", err)
+ }
+
+ return nil
+}
+
+// WriteProjectFiles writes both compose and optional env files to a project directory
+// projectsRoot is the allowed root directory to prevent path traversal attacks
+func WriteProjectFiles(projectsRoot, dirPath, composeContent string, envContent *string) error {
+ if err := WriteComposeFile(projectsRoot, dirPath, composeContent); err != nil {
+ return err
+ }
+
+ if envContent != nil && *envContent != "" {
+ if err := WriteEnvFile(projectsRoot, dirPath, *envContent); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+// WriteTemplateFile writes a template file (like .compose.template or .env.template)
+func WriteTemplateFile(filePath, content string) error {
+ dir := filepath.Dir(filePath)
+ if err := os.MkdirAll(dir, DirPerm); err != nil {
+ return fmt.Errorf("failed to create template directory: %w", err)
+ }
+
+ if err := os.WriteFile(filePath, []byte(content), FilePerm); err != nil {
+ return fmt.Errorf("failed to write template file: %w", err)
+ }
+
+ return nil
+}
+
+// WriteFileWithPerm is a generic file writer with custom permissions
+func WriteFileWithPerm(filePath, content string, perm os.FileMode) error {
+ dir := filepath.Dir(filePath)
+ if err := os.MkdirAll(dir, DirPerm); err != nil {
+ return fmt.Errorf("failed to create directory: %w", err)
+ }
+
+ if err := os.WriteFile(filePath, []byte(content), perm); err != nil {
+ return fmt.Errorf("failed to write file: %w", err)
+ }
+
+ return nil
+}
diff --git a/backend/internal/utils/projects/env.go b/backend/internal/utils/projects/env.go
index 7b7481c29..b22f40f5b 100644
--- a/backend/internal/utils/projects/env.go
+++ b/backend/internal/utils/projects/env.go
@@ -11,6 +11,8 @@ import (
"time"
)
+const filePerm = 0644
+
const (
globalEnvFileName = ".env.global"
projectEnvFileName = ".env"
@@ -73,7 +75,11 @@ func (l *EnvLoader) loadProcessEnv() EnvMap {
func (l *EnvLoader) ensureGlobalEnvFile(ctx context.Context, path string) error {
if _, err := os.Stat(path); os.IsNotExist(err) {
header := fmt.Sprintf(globalEnvHeader, time.Now().Format(time.RFC3339))
- if werr := os.WriteFile(path, []byte(header), 0644); werr != nil {
+ dir := filepath.Dir(path)
+ if err := os.MkdirAll(dir, 0755); err != nil {
+ return fmt.Errorf("create dir: %w", err)
+ }
+ if werr := os.WriteFile(path, []byte(header), filePerm); werr != nil {
return fmt.Errorf("write file: %w", werr)
}
slog.InfoContext(ctx, "Created global env file", "path", path)