windows: fix ModTime to cover Filetime zero value

Filetime.Nanoseconds() has a major drawback: the returned int64 is too
small to represent Filetime's zero value (January 1, 1601) in terms of
nanoseconds since Epoch (00:00:00 UTC, January 1, 1970); MinInt64 only dates
back to year 1677.

This has real-life implications, e.g., some Windows sub systems
(Perflib, to name one) create registry keys with the last write time
property set to zero. In this case, ModTime() reports an
underflow-affected value of 2185-07-22T00:34:33.709551+01:00.

This commit drops usage of Nanoseconds() in favor of a conversion that
converts first to seconds and nanoseconds before gauging thus is capable
to cover the full range of Filetime values. Additionally, ModTimeZero()
provides a convenient way to check for a last write time value of zero
in analogy to time.Time.IsZero(); no need to specify January 1, 1601
manually.

Fixes golang/go#74335

Author: gremat

windows/registry/key.go

@@ -198,7 +198,20 @@ type KeyInfo struct {
 
 // ModTime returns the key's last write time.
 func (ki *KeyInfo) ModTime() time.Time {
-	return time.Unix(0, ki.lastWriteTime.Nanoseconds())
+	lastHigh, lastLow := ki.lastWriteTime.HighDateTime, ki.lastWriteTime.LowDateTime
+	// 100-nanosecond intervals since January 1, 1601
+	hsec := uint64(lastHigh)<<32 + uint64(lastLow)
+	// Convert _before_ gauging; the nanosecond difference between Epoch (00:00:00
+	// UTC, January 1, 1970) and Filetime's zero offset (January 1, 1601) is out
+	// of bounds for int64: -11644473600*1e7*1e2 < math.MinInt64
+	sec := int64(hsec/1e7) - 11644473600
+	nsec := int64(hsec%1e7) * 100
+	return time.Unix(sec, nsec)
+}
+
+// ModTimeZero reports whether the key's last write time is zero.
+func (ki *KeyInfo) ModTimeZero() bool {
+	return ki.lastWriteTime.LowDateTime == 0 && ki.lastWriteTime.HighDateTime == 0
 }
 
 // Stat retrieves information about the open key k.

windows/registry/registry_test.go

@@ -9,6 +9,7 @@ package registry_test
 import (
 	"bytes"
 	"crypto/rand"
+	"errors"
 	"os"
 	"syscall"
 	"testing"
@@ -674,3 +675,30 @@ func GetDynamicTimeZoneInformation(dtzi *DynamicTimezoneinformation) (rc uint32,
 	}
 	return
 }
+
+func TestModTimeZeroValue(t *testing.T) {
+	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009`, registry.READ)
+	if err != nil {
+		if errors.Is(err, syscall.ERROR_FILE_NOT_FOUND) {
+			t.Skip("Perflib key not found; skipping")
+		}
+		t.Fatal(err)
+	}
+	defer k.Close()
+
+	// Modification time of Perflib keys is known to be set to
+	// Filetime's zero value: get stats and check.
+	stats, err := k.Stat()
+	if err != nil {
+		t.Fatal(err)
+	}
+	// First verify input is zero (assume ModTimeZero uses it directly).
+	if !stats.ModTimeZero() {
+		t.Error("Modification time of Perflib key should be zero")
+	}
+	// Then check ModTime directly thus conversion implicitly.
+	modTime := stats.ModTime()
+	if !modTime.Equal(time.Date(1601, time.January, 1, 0, 0, 0, 0, time.UTC)) {
+		t.Errorf("ModTime should be 1601-01-01, but is %v", modTime)
+	}
+}

windows/syscall_windows.go

@@ -740,7 +740,7 @@ func Ftruncate(fd Handle, length int64) (err error) {
 func Gettimeofday(tv *Timeval) (err error) {
 	var ft Filetime
 	GetSystemTimeAsFileTime(&ft)
-	*tv = NsecToTimeval(ft.Nanoseconds())
+	*tv = FiletimeToTimeval(ft)
 	return nil
 }
 
@@ -773,8 +773,8 @@ func Utimes(path string, tv []Timeval) (err error) {
 		return e
 	}
 	defer CloseHandle(h)
-	a := NsecToFiletime(tv[0].Nanoseconds())
-	w := NsecToFiletime(tv[1].Nanoseconds())
+	a := TimevalToFiletime(tv[0])
+	w := TimevalToFiletime(tv[1])
 	return SetFileTime(h, nil, &a, &w)
 }
 

windows/types_windows.go

@@ -779,10 +779,33 @@ func (tv *Timeval) Nanoseconds() int64 {
 	return (int64(tv.Sec)*1e6 + int64(tv.Usec)) * 1e3
 }
 
+func TimevalToFiletime(tv Timeval) Filetime {
+	// Convert to 100-nanosecond intervals
+	hsec := uint64(tv.Sec)*1e7 + uint64(tv.Usec)/100
+	// Change starting time to January 1, 1601
+	// Note: No overflow here (11644473600*1e7 < math.MaxUint64/1e2)
+	hsec += 116444736000000000
+	// Split into high / low.
+	return Filetime{
+		LowDateTime:  uint32(hsec & 0xffffffff),
+		HighDateTime: uint32(hsec >> 32 & 0xffffffff),
+	}
+}
+
+// NsecToTimeval converts a nanosecond value nsec to a Timeval tv. The result is
+// undefined if the nanosecond value cannot be represented by a Timeval (values
+// equivalent to dates before the year 1901 or after the year 2038).
 func NsecToTimeval(nsec int64) (tv Timeval) {
-	tv.Sec = int32(nsec / 1e9)
-	tv.Usec = int32(nsec % 1e9 / 1e3)
-	return
+	// Ignore overflow (math.MaxInt64/1e9 > math.MaxInt32)
+	sec := int32(nsec / 1e9)
+	usec := int32(nsec % 1e9 / 1e3)
+	if usec < 0 {
+		usec += 1e6
+		sec--
+	}
+	tv.Sec = sec
+	tv.Usec = usec
+	return tv
 }
 
 type Overlapped struct {
@@ -805,22 +828,48 @@ type Filetime struct {
 	HighDateTime uint32
 }
 
-// Nanoseconds returns Filetime ft in nanoseconds
+// Unix returns ft in seconds and nanoseconds
 // since Epoch (00:00:00 UTC, January 1, 1970).
-func (ft *Filetime) Nanoseconds() int64 {
+func (ft *Filetime) Unix() (sec, nsec int64) {
 	// 100-nanosecond intervals since January 1, 1601
-	nsec := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime)
-	// change starting time to the Epoch (00:00:00 UTC, January 1, 1970)
-	nsec -= 116444736000000000
-	// convert into nanoseconds
-	nsec *= 100
-	return nsec
+	hsec := uint64(ft.HighDateTime)<<32 + uint64(ft.LowDateTime)
+	// Convert _before_ gauging; the nanosecond difference between Epoch (00:00:00
+	// UTC, January 1, 1970) and Filetime's zero offset (January 1, 1601) is out
+	// of bounds for int64: -11644473600*1e7*1e2 < math.MinInt64
+	sec = int64(hsec/1e7) - 11644473600
+	nsec = int64(hsec%1e7) * 100
+	return sec, nsec
+}
+
+// Nanoseconds returns ft in nanoseconds since Epoch (00:00:00 UTC,
+// January 1, 1970). The result is undefined if the Filetime cannot be
+// represented by an int64 (values equivalent to dates before the year
+// 1677 or after the year 2262). Note that this explicitly excludes the
+// zero value of Filetime, which is equivalent to January 1, 1601.
+//
+// Deprecated: use Unix instead, which returns both seconds and
+// nanoseconds thus covers the full available range of Filetime.
+func (ft *Filetime) Nanoseconds() int64 {
+	sec, nsec := ft.Unix()
+	return (sec*1e9 + nsec)
+}
+
+// FiletimeToTimeval converts a Filetime ft to a Timeval tv. The result is
+// undefined if the Filetime cannot be represented by a Timeval (values
+// equivalent to dates before the year 1901 or after the year 2038).
+func FiletimeToTimeval(ft Filetime) (tv Timeval) {
+	sec, nsec := ft.Unix()
+	// Ignore overflow (math.MaxUint64*1e2/1e9 > math.MaxInt32)
+	tv.Sec = int32(sec)
+	tv.Usec = int32(nsec / 1e3)
+	return tv
 }
 
 func NsecToFiletime(nsec int64) (ft Filetime) {
 	// convert into 100-nanosecond
 	nsec /= 100
 	// change starting time to January 1, 1601
+	// note: no overflow here (11644473600*1e7 < math.MaxInt64/1e1)
 	nsec += 116444736000000000
 	// split into high / low
 	ft.LowDateTime = uint32(nsec & 0xffffffff)