Skip to content

Modern Docker Management, Designed for Everyone

fix: stop leaking Arcane's own process environment into compose variable interpolation (#3508)

Kyle Mendellb475a332fac5
diff --git a/backend/pkg/projects/custom_labels.go b/backend/pkg/projects/custom_labels.go
index 7ddb06124..7e1355b61 100644
--- a/backend/pkg/projects/custom_labels.go
+++ b/backend/pkg/projects/custom_labels.go
@@ -205,7 +205,7 @@ func loadComposeProjectForMetadataFromFileInternal(ctx context.Context, composeF
}
func loadComposeEnvironment(workdir string) map[string]string {
- envMap := loadProcessEnv()
+ envMap := allowedProcessEnvInternal()
if workdir == "" {
return envMap
}
@@ -269,16 +269,6 @@ func mergeEnvFromDotEnv(envMap map[string]string, workdir string) map[string]str
return merged
}
-func loadProcessEnv() map[string]string {
- envMap := make(map[string]string)
- for _, kv := range os.Environ() {
- if k, v, ok := strings.Cut(kv, "="); ok {
- envMap[k] = v
- }
- }
- return envMap
-}
-
func parseIncludePaths(composeFilePath string) ([]string, error) {
content, err := os.ReadFile(composeFilePath)
if err != nil {
diff --git a/backend/pkg/projects/env.go b/backend/pkg/projects/env.go
index 0b9ebd609..325b6d1b4 100644
--- a/backend/pkg/projects/env.go
+++ b/backend/pkg/projects/env.go
@@ -12,7 +12,6 @@ import (
"sort"
"strconv"
"strings"
- "sync"
"time"
"emperror.dev/errors"
@@ -70,8 +69,6 @@ type envFileCacheEntry struct {
}
var (
- processEnvOnce sync.Once
- processEnvSnapshot EnvMap
globalEnvFileCache = hot.NewHotCache[string, envFileCacheEntry](hot.LRU, 4096).Build()
projectEnvFileCache = hot.NewHotCache[string, envFileCacheEntry](hot.LRU, 4096).Build()
)
@@ -84,12 +81,33 @@ func NewEnvLoader(projectsDir, workdir string, autoInjectEnv bool) *EnvLoader {
}
}
+// processEnvAllowlist is the only part of Arcane's own process environment
+// that flows into compose interpolation of managed projects: timezone and
+// locale, whose container values are safe to share. Everything else is
+// excluded so Arcane's variables never leak into ${VAR} references or
+// pass-through environment entries — its PORT collides with project port
+// mappings, secrets would be readable from any compose file, and vars like
+// HOME or PUID carry container-internal values that are wrong for projects.
+var processEnvAllowlist = []string{"TZ", "LANG", "LANGUAGE", "LC_ALL"}
+
+func allowedProcessEnvInternal() EnvMap {
+ envMap := make(EnvMap)
+ for _, key := range processEnvAllowlist {
+ if val, ok := os.LookupEnv(key); ok {
+ envMap[key] = val
+ }
+ }
+ return envMap
+}
+
// LoadEnvironment loads and merges environment variables from all sources:
-// 1. Process environment
+// 1. Allowlisted process environment (TZ)
// 2. Global .env.global file (from projects directory)
// 3. Project-specific .env file (from workdir)
+// The rest of the Arcane process environment is intentionally excluded so its
+// own variables never leak into compose interpolation of managed projects.
func (l *EnvLoader) LoadEnvironment(ctx context.Context) (envMap EnvMap, injectionVars EnvMap, err error) {
- envMap = cloneEnvMapInternal(loadProcessEnvSnapshotInternal())
+ envMap = allowedProcessEnvInternal()
injectionVars = make(EnvMap)
if strings.TrimSpace(l.projectsDir) != "" {
@@ -111,18 +129,6 @@ func (l *EnvLoader) LoadEnvironment(ctx context.Context) (envMap EnvMap, injecti
return envMap, injectionVars, nil
}
-func loadProcessEnvSnapshotInternal() EnvMap {
- processEnvOnce.Do(func() {
- processEnvSnapshot = make(EnvMap)
- for _, kv := range os.Environ() {
- if k, v, ok := strings.Cut(kv, "="); ok {
- processEnvSnapshot[k] = v
- }
- }
- })
- return processEnvSnapshot
-}
-
func (l *EnvLoader) loadAndMergeGlobalEnv(ctx context.Context, path string, envMap, injectionVars EnvMap) error {
entry, err := loadCachedEnvFileInternal(ctx, globalEnvFileCache, path, path, envMap)
if err != nil {
@@ -133,9 +139,7 @@ func (l *EnvLoader) loadAndMergeGlobalEnv(ctx context.Context, path string, envM
}
for k, v := range entry.values {
- if _, exists := envMap[k]; !exists {
- envMap[k] = v
- }
+ envMap[k] = v
injectionVars[k] = v
}
@@ -234,12 +238,6 @@ func validEnvFileCacheEntryInternal(entry envFileCacheEntry) bool {
return entry.exists && info.ModTime().Equal(entry.mtime)
}
-func cloneEnvMapInternal(src EnvMap) EnvMap {
- dst := make(EnvMap, len(src))
- maps.Copy(dst, src)
- return dst
-}
-
func parseProjectEnvFileExistingInternal(path string, contextEnv EnvMap) (EnvMap, error) {
content, err := os.ReadFile(path)
if err != nil {
@@ -259,14 +257,13 @@ func ParseProjectEnvFile(path string, contextEnv EnvMap) (EnvMap, error) {
}
// ParseProjectEnvContent parses project .env content from a string using
-// compose-go's dotenv parser with variable expansion. Lookups check contextEnv
-// first (previously loaded vars), then the process environment.
+// compose-go's dotenv parser with variable expansion. Lookups resolve from
+// contextEnv (previously loaded vars) only; the Arcane process environment is
+// intentionally never consulted so its variables don't leak into project env.
func ParseProjectEnvContent(content string, contextEnv EnvMap) (EnvMap, error) {
lookupFn := func(key string) (string, bool) {
- if val, ok := contextEnv[key]; ok {
- return val, true
- }
- return os.LookupEnv(key)
+ val, ok := contextEnv[key]
+ return val, ok
}
envMap, err := dotenv.ParseWithLookup(strings.NewReader(content), lookupFn)
diff --git a/backend/pkg/projects/load.go b/backend/pkg/projects/load.go
index 9f4164364..7afe66ea2 100644
--- a/backend/pkg/projects/load.go
+++ b/backend/pkg/projects/load.go
@@ -162,10 +162,7 @@ func LoadComposeProjectFromContent(ctx context.Context, opts projecttypes.Compos
}
}
- envMap := maps.Clone(loadProcessEnvSnapshotInternal())
- if envMap == nil {
- envMap = make(EnvMap)
- }
+ envMap := allowedProcessEnvInternal()
if strings.TrimSpace(opts.EnvContent) != "" {
parsedEnv, parseErr := ParseProjectEnvContent(opts.EnvContent, envMap)
if parseErr != nil {
diff --git a/backend/pkg/projects/load_test.go b/backend/pkg/projects/load_test.go
index 8cf8e9fa2..268270c41 100644
--- a/backend/pkg/projects/load_test.go
+++ b/backend/pkg/projects/load_test.go
@@ -7,6 +7,7 @@ import (
"strings"
"testing"
+ composetypes "github.com/compose-spec/compose-go/v2/types"
"github.com/docker/compose/v5/pkg/api"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -161,6 +162,53 @@ func TestLoadComposeProject_MergesComposeOverrideFile(t *testing.T) {
assert.Equal(t, []string{basePath, overridePath}, project.ComposeFiles)
}
+func TestLoadComposeProject_ArcaneProcessEnvInterpolation(t *testing.T) {
+ // Arcane's own env (e.g. PORT) must not leak into compose interpolation of
+ // managed projects: ${PORT:-8191} falls back to its default (issue #3499).
+ // Allowlisted vars like TZ still flow through.
+ t.Setenv("PORT", "3552")
+ t.Setenv("TZ", "America/Chicago")
+
+ testCases := []struct {
+ name string
+ compose string
+ check func(t *testing.T, app composetypes.ServiceConfig)
+ }{
+ {
+ name: "blocked var falls back to compose default",
+ compose: "services:\n app:\n image: nginx:alpine\n ports:\n - \"${PORT:-8191}:8191\"\n",
+ check: func(t *testing.T, app composetypes.ServiceConfig) {
+ t.Helper()
+ require.Len(t, app.Ports, 1)
+ assert.Equal(t, "8191", app.Ports[0].Published)
+ },
+ },
+ {
+ name: "allowlisted var flows through",
+ compose: "services:\n app:\n image: nginx:alpine\n environment:\n TZ: ${TZ:-UTC}\n",
+ check: func(t *testing.T, app composetypes.ServiceConfig) {
+ t.Helper()
+ require.NotNil(t, app.Environment["TZ"])
+ assert.Equal(t, "America/Chicago", *app.Environment["TZ"])
+ },
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ dir := t.TempDir()
+ basePath := filepath.Join(dir, "compose.yaml")
+ require.NoError(t, os.WriteFile(basePath, []byte(tc.compose), 0o600))
+
+ project, err := LoadComposeProject(context.Background(), basePath, "demo", dir, false, nil, nil, nil, false)
+ require.NoError(t, err)
+ require.NotNil(t, project)
+
+ tc.check(t, project.Services["app"])
+ })
+ }
+}
+
func TestLoadComposeProject_DoesNotMergeOverrideForCustomBaseName(t *testing.T) {
t.Parallel()