RebaseArchiveEntries: fix archive path rebasing

Handle rebasing from the archive root explicitly so that both relative
and absolute entry names are joined to `newBase` with exactly one path
separator.

Also restrict rebasing to complete path prefixes. The previous use of
`strings.Replace` could replace `oldBase` outside the beginning of the
name or as part of another path component, such as rebasing `origin` in
`original/file`.

Apply the same handling to hardlink targets, while preserving the
remainder of archive paths without cleaning or canonicalizing them.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Author: thaJeztah

copy.go

@@ -316,19 +316,40 @@ func PrepareArchiveCopy(srcContent io.Reader, srcInfo, dstInfo CopyInfo) (dstDir
 	}
 }
 
+// newNameRebaser returns a function that replaces oldBase with newBase at the
+// beginning of POSIX-style archive entry names. It converts oldBase and newBase
+// to forward-slash form and trims trailing slashes.
+//
+// When rebasing from the archive root, the returned function removes all
+// leading slashes from names. It otherwise preserves the remainder verbatim
+// and does not clean or canonicalize paths.
+func newNameRebaser(oldBase, newBase string) func(string) string {
+	oldBase = strings.TrimRight(filepath.ToSlash(oldBase), "/")
+	newBase = strings.TrimRight(filepath.ToSlash(newBase), "/")
+
+	if oldBase == "" {
+		return func(name string) string {
+			name = strings.TrimLeft(name, "/")
+			if newBase == "" {
+				return name
+			}
+			return newBase + "/" + name
+		}
+	}
+
+	return func(name string) string {
+		suffix, ok := strings.CutPrefix(name, oldBase)
+		if !ok || suffix != "" && !strings.HasPrefix(suffix, "/") {
+			return name
+		}
+		return newBase + suffix
+	}
+}
+
 // RebaseArchiveEntries rewrites the given srcContent archive replacing
 // an occurrence of oldBase with newBase at the beginning of entry names.
 func RebaseArchiveEntries(srcContent io.Reader, oldBase, newBase string) io.ReadCloser {
-	oldBase = filepath.ToSlash(oldBase)
-	newBase = filepath.ToSlash(newBase)
-
-	if oldBase == "/" {
-		// If oldBase specifies the root directory, use an empty string as
-		// oldBase instead so that newBase doesn't replace the path separator
-		// that all paths will start with.
-		oldBase = ""
-	}
-
+	rebase := newNameRebaser(oldBase, newBase)
 	rebased, w := io.Pipe()
 
 	go func() {
@@ -356,9 +377,9 @@ func RebaseArchiveEntries(srcContent io.Reader, oldBase, newBase string) io.Read
 			//
 			// To fix, set the format to PAX here. See docker/for-linux issue #484.
 			hdr.Format = tar.FormatPAX
-			hdr.Name = strings.Replace(hdr.Name, oldBase, newBase, 1)
+			hdr.Name = rebase(hdr.Name)
 			if hdr.Typeflag == tar.TypeLink {
-				hdr.Linkname = strings.Replace(hdr.Linkname, oldBase, newBase, 1)
+				hdr.Linkname = rebase(hdr.Linkname)
 			}
 
 			if err = rebasedTar.WriteHeader(hdr); err != nil {

copy_test.go

@@ -20,6 +20,47 @@ func TestRebaseArchiveEntriesPlatformPaths(t *testing.T) {
 		wantName     string
 		wantLinkName string
 	}{
+		{
+			name:       "rebase relative name from root",
+			oldBase:    "/",
+			newBase:    "prefix",
+			headerName: "foo/bar",
+			wantName:   "prefix/foo/bar",
+		},
+		{
+			name:       "rebase absolute name from root",
+			oldBase:    "/",
+			newBase:    "prefix",
+			headerName: "/foo/bar",
+			wantName:   "prefix/foo/bar",
+		},
+		{
+			name:       "rebase name with multiple leading slashes from root",
+			oldBase:    "/",
+			newBase:    "prefix",
+			headerName: "///foo/bar",
+			wantName:   "prefix/foo/bar",
+		},
+		{
+			name:       "root with multiple trailing slashes",
+			oldBase:    "///",
+			newBase:    "prefix",
+			headerName: "/foo/bar",
+			wantName:   "prefix/foo/bar",
+		},
+		{
+			name:       "rebase absolute name from root to empty",
+			oldBase:    "/",
+			newBase:    "",
+			headerName: "/foo/bar",
+			wantName:   "foo/bar",
+		},
+		{
+			name:       "rebase absolute name from root to empty",
+			oldBase:    "/",
+			headerName: "/foo/bar",
+			wantName:   "foo/bar",
+		},
 		{
 			name:       "regular file",
 			oldBase:    filepath.Join("origin", "subdir"),
@@ -34,6 +75,55 @@ func TestRebaseArchiveEntriesPlatformPaths(t *testing.T) {
 			headerName: "origin/subdir/file",
 			wantName:   "dest/target/file",
 		},
+		{
+			name:       "name equals old base",
+			oldBase:    "origin",
+			newBase:    "dest",
+			headerName: "origin",
+			wantName:   "dest",
+		},
+		{
+			name:       "old base not at beginning",
+			oldBase:    "origin",
+			newBase:    "dest",
+			headerName: "other/origin/file",
+			wantName:   "other/origin/file",
+		},
+		{
+			name:       "old base is partial path component",
+			oldBase:    "origin",
+			newBase:    "dest",
+			headerName: "original/file",
+			wantName:   "original/file",
+		},
+		{
+			name:       "old base with multiple trailing slashes",
+			oldBase:    "origin///",
+			newBase:    "dest",
+			headerName: "origin/file",
+			wantName:   "dest/file",
+		},
+		{
+			name:       "new base with multiple trailing slashes",
+			oldBase:    "origin",
+			newBase:    "dest///",
+			headerName: "origin/file",
+			wantName:   "dest/file",
+		},
+		{
+			name:       "preserve unclean name",
+			oldBase:    "/",
+			newBase:    "prefix",
+			headerName: "foo/../bar",
+			wantName:   "prefix/foo/../bar",
+		},
+		{
+			name:       "do not rebase partial path component match",
+			oldBase:    "foo",
+			newBase:    "prefix",
+			headerName: "foobar/baz",
+			wantName:   "foobar/baz",
+		},
 		{
 			name:         "hardlink",
 			oldBase:      filepath.Join("origin", "subdir"),
@@ -52,6 +142,24 @@ func TestRebaseArchiveEntriesPlatformPaths(t *testing.T) {
 			wantName:     "dest/target/link",
 			wantLinkName: "dest/target/file",
 		},
+		{
+			name:         "hardlink rebase relative names from root",
+			oldBase:      "/",
+			newBase:      "prefix",
+			headerName:   "link",
+			linkName:     "target",
+			wantName:     "prefix/link",
+			wantLinkName: "prefix/target",
+		},
+		{
+			name:         "hardlink rebase absolute names from root",
+			oldBase:      "/",
+			newBase:      "prefix",
+			headerName:   "/link",
+			linkName:     "/target",
+			wantName:     "prefix/link",
+			wantLinkName: "prefix/target",
+		},
 	}
 
 	for _, tc := range cases {