archive: fix creation time updates on Windows

Restore updating the creation time when applying timestamps on
Windows. The previous refactoring to os.Root.Chtimes() only updated
the access and modification times, causing a regression.

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

Author: thaJeztah

archive.go

@@ -608,13 +608,13 @@ func createTarFile(root *os.Root, dstPath string, hdr *tar.Header, reader io.Rea
 		// Follow the hardlink only when its target is not itself a symlink.
 		fi, err := root.Lstat(filepath.FromSlash(path.Clean(hdr.Linkname)))
 		if err == nil && fi.Mode()&os.ModeSymlink == 0 {
-			if err := root.Chtimes(dstPath, aTime, mTime); err != nil {
+			if err := chtimes(root, dstPath, aTime, mTime); err != nil {
 				return err
 			}
 		}
 	default:
 		// All other file types follow symlinks.
-		if err := root.Chtimes(dstPath, aTime, mTime); err != nil {
+		if err := chtimes(root, dstPath, aTime, mTime); err != nil {
 			return err
 		}
 	}
@@ -994,7 +994,7 @@ loop:
 
 	for _, d := range dirs {
 		aTime := boundTime(latestTime(d.hdr.AccessTime, d.hdr.ModTime))
-		if err := root.Chtimes(d.name, aTime, boundTime(d.hdr.ModTime)); err != nil {
+		if err := chtimes(root, d.name, aTime, boundTime(d.hdr.ModTime)); err != nil {
 			return err
 		}
 	}

archive_windows_test.go

@@ -84,9 +84,9 @@ func TestChtimesSetsCreationTime(t *testing.T) {
 	t.Cleanup(func() { _ = root.Close() })
 
 	want := time.Date(2001, time.February, 3, 4, 5, 6, 0, time.UTC)
-	assert.NilError(t, root.Chtimes("file", want, want))
+	assert.NilError(t, chtimes(root, "file", want, want))
 
-	fi, err := os.Stat(file)
+	fi, err := root.Stat("file")
 	assert.NilError(t, err)
 
 	data, ok := fi.Sys().(*syscall.Win32FileAttributeData)

changes_test.go

@@ -91,10 +91,17 @@ func createSampleDir(t *testing.T, root string) {
 	provisionSampleDir(t, root, files)
 }
 
-func provisionSampleDir(t *testing.T, root string, files []FileData) {
+func provisionSampleDir(t *testing.T, rootPath string, files []FileData) {
+	t.Helper()
+
+	root, err := os.OpenRoot(rootPath)
+	assert.NilError(t, err)
+	t.Cleanup(func() { _ = root.Close() })
+
 	now := time.Now()
 	for _, info := range files {
-		p := path.Join(root, info.path)
+		name := path.Clean(info.path)
+		p := filepath.Join(rootPath, filepath.FromSlash(name))
 		switch info.filetype {
 		case Dir:
 			err := os.MkdirAll(p, info.permissions)
@@ -109,7 +116,7 @@ func provisionSampleDir(t *testing.T, root string, files []FileData) {
 
 		if info.filetype != Symlink {
 			// Set a consistent ctime, atime for all files and dirs
-			err := chtimes(p, now, now)
+			err := chtimes(root, filepath.FromSlash(name), now, now)
 			assert.NilError(t, err)
 		}
 	}
@@ -267,66 +274,70 @@ func TestChangesDirsEmpty(t *testing.T) {
 	assert.NilError(t, os.RemoveAll(dst))
 }
 
-func mutateSampleDir(t *testing.T, root string) {
+func mutateSampleDir(t *testing.T, rootPath string) {
+	root, err := os.OpenRoot(rootPath)
+	assert.NilError(t, err)
+	t.Cleanup(func() { _ = root.Close() })
+
 	// Remove a regular file
-	err := os.RemoveAll(path.Join(root, "file1"))
+	err = root.RemoveAll("file1")
 	assert.NilError(t, err)
 
 	// Remove a directory
-	err = os.RemoveAll(path.Join(root, "dir1"))
+	err = root.RemoveAll("dir1")
 	assert.NilError(t, err)
 
 	// Remove a symlink
-	err = os.RemoveAll(path.Join(root, "symlink1"))
+	err = root.RemoveAll("symlink1")
 	assert.NilError(t, err)
 
 	// Rewrite a file
-	err = os.WriteFile(path.Join(root, "file2"), []byte("fileNN\n"), 0o777)
+	err = root.WriteFile("file2", []byte("fileNN\n"), 0o777)
 	assert.NilError(t, err)
 
 	// Replace a file
-	err = os.RemoveAll(path.Join(root, "file3"))
+	err = root.RemoveAll("file3")
 	assert.NilError(t, err)
-	err = os.WriteFile(path.Join(root, "file3"), []byte("fileMM\n"), 0o404)
+	err = root.WriteFile("file3", []byte("fileMM\n"), 0o404)
 	assert.NilError(t, err)
 
 	// Touch file
-	err = chtimes(path.Join(root, "file4"), time.Now().Add(time.Second), time.Now().Add(time.Second))
+	err = chtimes(root, "file4", time.Now().Add(time.Second), time.Now().Add(time.Second))
 	assert.NilError(t, err)
 
 	// Replace file with dir
-	err = os.RemoveAll(path.Join(root, "file5"))
+	err = root.RemoveAll("file5")
 	assert.NilError(t, err)
-	err = os.MkdirAll(path.Join(root, "file5"), 0o666)
+	err = root.Mkdir("file5", 0o666)
 	assert.NilError(t, err)
 
 	// Create new file
-	err = os.WriteFile(path.Join(root, "filenew"), []byte("filenew\n"), 0o777)
+	err = root.WriteFile("filenew", []byte("filenew\n"), 0o777)
 	assert.NilError(t, err)
 
 	// Create new dir
-	err = os.MkdirAll(path.Join(root, "dirnew"), 0o766)
+	err = root.MkdirAll("dirnew", 0o766)
 	assert.NilError(t, err)
 
 	// Create a new symlink
-	err = os.Symlink("targetnew", path.Join(root, "symlinknew"))
+	err = root.Symlink("targetnew", "symlinknew")
 	assert.NilError(t, err)
 
 	// Change a symlink
-	err = os.RemoveAll(path.Join(root, "symlink2"))
+	err = root.RemoveAll("symlink2")
 	assert.NilError(t, err)
 
-	err = os.Symlink("target2change", path.Join(root, "symlink2"))
+	err = root.Symlink("target2change", "symlink2")
 	assert.NilError(t, err)
 
 	// Replace dir with file
-	err = os.RemoveAll(path.Join(root, "dir2"))
+	err = root.RemoveAll("dir2")
 	assert.NilError(t, err)
-	err = os.WriteFile(path.Join(root, "dir2"), []byte("dir2\n"), 0o777)
+	err = root.WriteFile("dir2", []byte("dir2\n"), 0o777)
 	assert.NilError(t, err)
 
 	// Touch dir
-	err = chtimes(path.Join(root, "dir3"), time.Now().Add(time.Second), time.Now().Add(time.Second))
+	err = chtimes(root, "dir3", time.Now().Add(time.Second), time.Now().Add(time.Second))
 	assert.NilError(t, err)
 }
 

diff.go

@@ -213,7 +213,7 @@ func UnpackLayer(dest string, layer io.Reader, options *TarOptions) (size int64,
 	}
 
 	for _, d := range dirs {
-		if err := root.Chtimes(d.name, boundTime(latestTime(d.hdr.AccessTime, d.hdr.ModTime)), boundTime(d.hdr.ModTime)); err != nil {
+		if err := chtimes(root, d.name, boundTime(latestTime(d.hdr.AccessTime, d.hdr.ModTime)), boundTime(d.hdr.ModTime)); err != nil {
 			return 0, err
 		}
 	}

time_nonwindows.go

@@ -14,12 +14,13 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-// chtimes changes the access time and modified time of a file at the given path.
+// chtimes changes the access and modification times of a file at the given
+// path relative to root.
+//
 // If the modified time is prior to the Unix Epoch (unixMinTime), or after the
-// end of Unix Time (unixEpochTime), os.Chtimes has undefined behavior. In this
-// case, Chtimes defaults to Unix Epoch, just in case.
-func chtimes(name string, atime time.Time, mtime time.Time) error {
-	return os.Chtimes(name, atime, mtime)
+// end of Unix Time (unixEpochTime), os.Chtimes has undefined behavior.
+func chtimes(root *os.Root, name string, atime, mtime time.Time) error {
+	return root.Chtimes(name, atime, mtime)
 }
 
 func lchtimes(root *os.Root, name string, atime, mtime time.Time) error {

time_windows.go

@@ -2,31 +2,89 @@ package archive
 
 import (
 	"os"
+	"path/filepath"
 	"time"
+	"unsafe"
 
 	"golang.org/x/sys/windows"
 )
 
-func chtimes(name string, atime time.Time, mtime time.Time) error {
-	if err := os.Chtimes(name, atime, mtime); err != nil {
-		return err
+// openForWriteAttributesAt opens name relative to parent with permission to
+// If noFollow is true, it does not follow reparse points.
+//
+// This implementation is based on Go's internal Windows Openat support:
+//
+//	https://github.com/golang/go/blob/go1.26.0/src/internal/syscall/windows/at_windows.go
+//
+// It is used by os.Root's Windows implementation for root-relative filesystem
+// operations:
+//
+//	https://github.com/golang/go/blob/go1.26.0/src/os/root_windows.go
+//
+// Keep this implementation aligned with the upstream code until an equivalent
+// operation is available from golang.org/x/sys/windows.
+func openForWriteAttributesAt(parent windows.Handle, name string, noFollow bool) (windows.Handle, error) {
+	name16, err := windows.UTF16FromString(name)
+	if err != nil {
+		return windows.InvalidHandle, err
 	}
 
-	pathp, err := windows.UTF16PtrFromString(name)
-	if err != nil {
-		return err
+	attrs := uint32(windows.OBJ_CASE_INSENSITIVE)
+	if noFollow {
+		attrs |= windows.OBJ_DONT_REPARSE
 	}
-	h, err := windows.CreateFile(pathp,
-		windows.FILE_WRITE_ATTRIBUTES, windows.FILE_SHARE_WRITE, nil,
-		windows.OPEN_EXISTING, windows.FILE_FLAG_BACKUP_SEMANTICS, 0)
+
+	var handle windows.Handle
+	err = windows.NtCreateFile(
+		&handle,
+		windows.SYNCHRONIZE|windows.FILE_WRITE_ATTRIBUTES,
+		&windows.OBJECT_ATTRIBUTES{
+			Length:        uint32(unsafe.Sizeof(windows.OBJECT_ATTRIBUTES{})),
+			RootDirectory: parent,
+			ObjectName: &windows.NTUnicodeString{
+				Length:        uint16((len(name16) - 1) * 2), // #nosec G115 -- Length is USHORT by definition. A Windows path component cannot exceed uint16 bytes.
+				MaximumLength: uint16(len(name16) * 2),       // #nosec G115 -- MaximumLength is USHORT by definition. A Windows path component cannot exceed uint16 bytes.
+				Buffer:        &name16[0],
+			},
+			Attributes: attrs,
+		},
+		&windows.IO_STATUS_BLOCK{},
+		nil,
+		windows.FILE_ATTRIBUTE_NORMAL,
+		windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE|windows.FILE_SHARE_DELETE,
+		windows.FILE_OPEN,
+		windows.FILE_OPEN_FOR_BACKUP_INTENT|windows.FILE_SYNCHRONOUS_IO_NONALERT,
+		0, // EA buffer
+		0, // EA length
+	)
+	return handle, err
+}
+
+func chtimes(root *os.Root, name string, atime, mtime time.Time) error {
+	parent, err := root.OpenFile(filepath.Dir(name), os.O_RDONLY, 0)
 	if err != nil {
 		return err
 	}
-	defer windows.Close(h)
-	c := windows.NsecToFiletime(mtime.UnixNano())
-	return windows.SetFileTime(h, &c, nil, nil)
+	defer parent.Close()
+
+	return chtimesAt(parent, filepath.Base(name), atime, mtime, false)
 }
 
 func lchtimes(root *os.Root, name string, atime time.Time, mtime time.Time) error {
 	return nil
 }
+
+func chtimesAt(parent *os.File, name string, atime, mtime time.Time, noFollow bool) error {
+	h, err := openForWriteAttributesAt(windows.Handle(parent.Fd()), name, noFollow)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = windows.Close(h) }()
+
+	var (
+		creationTime     = windows.NsecToFiletime(mtime.UnixNano())
+		accessTime       = windows.NsecToFiletime(atime.UnixNano())
+		modificationTime = windows.NsecToFiletime(mtime.UnixNano())
+	)
+	return windows.SetFileTime(h, &creationTime, &accessTime, &modificationTime)
+}