"The handle is invalid" error when calling GetFileInformationByHandle with handle initialized with GetFileVersionInfoSize

I am trying to programmatically obtain file information with Go on Windows, including the time the file was created.

I found a function in golang.org/x/sys/windows that returns something with information on when a file is created is GetFileInformationByHandle (Go docs, Windows API docs). However, the code I wrote using this function gives me a The handle is invalid error.

Here is my code:

package main

import (
	"log"
	"os"

	"golang.org/x/sys/windows"
)

func main() {
	name := `C:\Windows\System32\cmd.exe`

	fileInfo, err := os.Stat(name)
	if err != nil {
		log.Fatalf("Unable to stat %s: %s", name, err.Error())
	}

	log.Printf("%s has base name %s.\n", name, fileInfo.Name())

	var handle windows.Handle
	_, err = windows.GetFileVersionInfoSize(name, &handle)
	if err != nil && err != windows.ERROR_FILE_NOT_FOUND && err != windows.ERROR_RESOURCE_TYPE_NOT_FOUND {
		log.Fatalf("GetFileVersionInfoSize error: path: %s %s", name, err.Error())
	}

	var hndlFileInfo windows.ByHandleFileInformation
	err = windows.GetFileInformationByHandle(handle, &hndlFileInfo)
	if err != nil {
		if err == windows.ERROR_INVALID_HANDLE { // https://learn.microsoft.com/en-us/windows/win32/debug/system-error-codes--0-499-
			log.Println("Error is invalid handle error.")
		}
		log.Fatalf("GetFileInformationByHandle error: path: %s %s", name, err.Error())
	}

	log.Println("Success!")
}

When I run this, I get the following output:

2023/01/11 14:43:19 C:\Windows\System32\cmd.exe has base name cmd.exe.
2023/01/11 14:43:19 Error is invalid handle error.
2023/01/11 14:43:19 GetFileInformationByHandle error: path: C:\Windows\System32\cmd.exe The handle is invalid.

I have confirmed that the file path is valid (plus the os.Stat call does not return an error):

I know the System32 directory is not visible for 32-bit Windows programs, but I have verified that my executable is a 64-bit program with the file tool on git-bash:

$ file win_handle_test.exe
win_handle_test.exe: PE32+ executable (console) x86-64 (stripped to external PDB), for MS Windows

Since the path should be valid, what could I be doing wrong so that I am getting an invalid handle?

Looks like Go has native support for what you're after right in its stock syscall package:

//go:build windows

package main

import (
	"fmt"
	"log"
	"os"
	"syscall"
)

func main() {
	log.SetFlags(0)

	fi, err := os.Stat(`C:\Windows\system32\cmd.exe`)
	if err != nil {
		log.Fatal(err)
	}

	fad, ok := fi.Sys().(*syscall.Win32FileAttributeData)
	if !ok {
		log.Println("No win32-native data")
	} else {
		fmt.Println(
			"FileAttributes:", fad.FileAttributes,
			"CreationTime:", fad.CreationTime,
			"LastAccessTime:", fad.LastAccessTime,
			"LastWriteTime:", fad.LastWriteTime,
			"FileSizeHigh:", fad.FileSizeHigh,
			"FileSizeLow:", fad.FileSizeLow,
		)
	}
}

On my system, I have:
filever$ GOOS=windows go build
filever$ wine ./filever.exe
FileAttributes: 32 CreationTime: {868251897 31002635} LastAccessTime: {1168986901 31008247} LastWriteTime: {868251897 31002635} FileSizeHigh: 0 FileSizeLow: 795516

I found an alternate way to get the creation time, based on this answer:

package main

import (
	"log"
	"os"
	"time"
	"syscall"
)

func main() {
	name := `C:\Windows\System32\cmd.exe`

	fileInfo, err := os.Stat(name)
	if err != nil {
		log.Fatalf("Unable to stat %s: %s", name, err.Error())
	}

	log.Printf("%s has base name %s.\n", name, fileInfo.Name())

	data := fileInfo.Sys().(*syscall.Win32FileAttributeData)
	cTime := time.Unix(0, data.CreationTime.Nanoseconds())

	log.Printf("cTime in UTC           : %v\n", cTime.UTC())
	log.Printf("cTime in local timezone: %v\n", cTime)
}

Output:

2023/01/11 15:03:58 C:\Windows\System32\cmd.exe has base name cmd.exe.
2023/01/11 15:03:58 cTime in UTC           : 2022-05-10 17:34:57.9429156 +0000 UTC
2023/01/11 15:03:58 cTime in local timezone: 2022-05-10 13:34:57.9429156 -0400 EDT

This output matches the created time in the properties view for the file.

Despite the FILETIME itself being in time since January 1, 1601 UTC, both time.Unix and the Nanoseconds function are based on time since January 1, 1970 UTC.