/* Copyright 2020 Docker Compose CLI authors Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package remote import ( "bufio" "bytes" "context" "fmt" "os" "os/exec" "path/filepath" "regexp" "strconv" "strings" "github.com/compose-spec/compose-go/v2/cli" "github.com/compose-spec/compose-go/v2/loader" "github.com/compose-spec/compose-go/v2/types" "github.com/docker/cli/cli/command" gitutil "github.com/moby/buildkit/frontend/dockerfile/dfgitutil" "github.com/sirupsen/logrus" "github.com/docker/compose/v5/pkg/api" ) const GIT_REMOTE_ENABLED = "COMPOSE_EXPERIMENTAL_GIT_REMOTE" func gitRemoteLoaderEnabled() (bool, error) { if v := os.Getenv(GIT_REMOTE_ENABLED); v != "" { enabled, err := strconv.ParseBool(v) if err != nil { return false, fmt.Errorf("COMPOSE_EXPERIMENTAL_GIT_REMOTE environment variable expects boolean value: %w", err) } return enabled, err } return true, nil } func NewGitRemoteLoader(dockerCli command.Cli, offline bool) loader.ResourceLoader { return gitRemoteLoader{ dockerCli: dockerCli, offline: offline, known: map[string]string{}, } } type gitRemoteLoader struct { dockerCli command.Cli offline bool known map[string]string } func (g gitRemoteLoader) Accept(path string) bool { _, _, err := gitutil.ParseGitRef(path) return err == nil } var commitSHA = regexp.MustCompile(`^[a-f0-9]{40}$`) func (g gitRemoteLoader) Load(ctx context.Context, path string) (string, error) { enabled, err := gitRemoteLoaderEnabled() if err != nil { return "", err } if !enabled { return "", fmt.Errorf("git remote resource is disabled by %q", GIT_REMOTE_ENABLED) } ref, _, err := gitutil.ParseGitRef(path) if err != nil { return "", err } local, ok := g.known[path] if !ok { if ref.Ref == "" { ref.Ref = "HEAD" // default branch } err = g.resolveGitRef(ctx, path, ref) if err != nil { return "", err } cache, err := cacheDir() if err != nil { return "", fmt.Errorf("initializing remote resource cache: %w", err) } local = gitEntryDir(cache, ref.Ref) if _, err := os.Stat(local); os.IsNotExist(err) { if g.offline { return "", nil } err = g.checkout(ctx, cache, ref) if err != nil { return "", err } } g.known[path] = local } if ref.SubDir != "" { if err := validateGitSubDir(local, ref.SubDir); err != nil { return "", err } local = filepath.Join(local, ref.SubDir) } stat, err := os.Stat(local) if err != nil { return "", err } if stat.IsDir() { local, err = findFile(cli.DefaultFileNames, local) } return local, err } func (g gitRemoteLoader) Dir(path string) string { return g.known[path] } // validateGitSubDir ensures a subdirectory path is contained within the base directory // and doesn't escape via path traversal. Unlike validatePathInBase for OCI artifacts, // this allows nested directories but prevents traversal outside the base. func validateGitSubDir(base, subDir string) error { cleanSubDir := filepath.Clean(subDir) if filepath.IsAbs(cleanSubDir) { return fmt.Errorf("git subdirectory must be relative, got: %s", subDir) } if cleanSubDir == ".." || strings.HasPrefix(cleanSubDir, "../") || strings.HasPrefix(cleanSubDir, "..\\") { return fmt.Errorf("git subdirectory path traversal detected: %s", subDir) } if len(cleanSubDir) >= 2 && cleanSubDir[1] == ':' { return fmt.Errorf("git subdirectory must be relative, got: %s", subDir) } targetPath := filepath.Join(base, cleanSubDir) cleanBase := filepath.Clean(base) cleanTarget := filepath.Clean(targetPath) // Ensure the target starts with the base path relPath, err := filepath.Rel(cleanBase, cleanTarget) if err != nil { return fmt.Errorf("invalid git subdirectory path: %w", err) } if relPath == ".." || strings.HasPrefix(relPath, "../") || strings.HasPrefix(relPath, "..\\") { return fmt.Errorf("git subdirectory escapes base directory: %s", subDir) } return nil } func (g gitRemoteLoader) resolveGitRef(ctx context.Context, path string, ref *gitutil.GitRef) error { if !commitSHA.MatchString(ref.Ref) { cmd := exec.CommandContext(ctx, "git", "ls-remote", "--exit-code", ref.Remote, ref.Ref) cmd.Env = g.gitCommandEnv() out, err := cmd.CombinedOutput() if err != nil { if cmd.ProcessState.ExitCode() == 2 { return fmt.Errorf("repository does not contain ref %s, output: %q: %w", path, string(out), err) } return fmt.Errorf("failed to access repository at %s:\n %s", ref.Remote, out) } if len(out) < 40 { return fmt.Errorf("unexpected git command output: %q", string(out)) } sha := string(out[:40]) if !commitSHA.MatchString(sha) { return fmt.Errorf("invalid commit sha %q", sha) } ref.Ref = sha } return nil } // cacheGitDir is the directory of the cache which holds the checkouts of the Git // repositories, one directory for each commit. Earlier releases checked them out at // the root of the cache, where they are no longer looked for: one which was left // incomplete by an interrupted run could be taken for a complete one. const cacheGitDir = "git" // gitEntryDir is the directory of the checkout of the commit. func gitEntryDir(cache, sha string) string { return filepath.Join(cache, cacheGitDir, sha) } // checkout fetches the commit into the cache. It does so in a directory of its own, // which is renamed to the one of the commit only once the checkout is complete: the // directory of a commit is therefore never a partial checkout, and needs no file // beside it to tell. func (g gitRemoteLoader) checkout(ctx context.Context, cache string, ref *gitutil.GitRef) error { gitCache := filepath.Join(cache, cacheGitDir) if err := os.MkdirAll(gitCache, 0o700); err != nil { return err } path, err := os.MkdirTemp(gitCache, ".checkout-") if err != nil { return err } defer func() { _ = os.RemoveAll(path) }() err = exec.CommandContext(ctx, "git", "init", path).Run() if err != nil { return err } cmd := exec.CommandContext(ctx, "git", "remote", "add", "origin", ref.Remote) cmd.Dir = path err = cmd.Run() if err != nil { return err } cmd = exec.CommandContext(ctx, "git", "fetch", "--depth=1", "origin", ref.Ref) cmd.Env = g.gitCommandEnv() cmd.Dir = path err = g.run(cmd) if err != nil { return err } cmd = exec.CommandContext(ctx, "git", "checkout", ref.Ref) cmd.Dir = path err = cmd.Run() if err != nil { return err } local := gitEntryDir(cache, ref.Ref) if err := os.Rename(path, local); err != nil { // another run placed the same commit first if _, statErr := os.Stat(local); statErr == nil { return nil } return err } return nil } func (g gitRemoteLoader) run(cmd *exec.Cmd) error { if logrus.IsLevelEnabled(logrus.DebugLevel) { output, err := cmd.CombinedOutput() scanner := bufio.NewScanner(bytes.NewBuffer(output)) for scanner.Scan() { line := scanner.Text() logrus.Debug(line) } return err } return cmd.Run() } func (g gitRemoteLoader) gitCommandEnv() []string { env := types.NewMapping(os.Environ()) if env["GIT_TERMINAL_PROMPT"] == "" { // Disable prompting for passwords by Git until user explicitly asks for it. env["GIT_TERMINAL_PROMPT"] = "0" } if env["GIT_SSH"] == "" && env["GIT_SSH_COMMAND"] == "" { // Disable any ssh connection pooling by Git and do not attempt to prompt the user. env["GIT_SSH_COMMAND"] = "ssh -o ControlMaster=no -o BatchMode=yes" } v := env.Values() return v } func findFile(names []string, pwd string) (string, error) { for _, n := range names { f := filepath.Join(pwd, n) if fi, err := os.Stat(f); err == nil && !fi.IsDir() { return f, nil } } return "", api.ErrNotFound } var _ loader.ResourceLoader = gitRemoteLoader{}