Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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.goindex 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, composeContentreturn 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, nareturn 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, naswitch {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, nareturn 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.goindex 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 errorsenvPath := 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.goindex 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 existif _, 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 existif _, 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.goindex 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 := basePathfolderName = sanitizedfor 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.gonew file mode 100644index 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.goindex 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)