From cb2bc4b34c281cf6ba61fc9723244e591854cd8f Mon Sep 17 00:00:00 2001 From: Simon Rozman Date: Wed, 6 Feb 2019 22:30:14 +0100 Subject: [PATCH] tun_windows: Introduce preliminary TUN interface creation Signed-off-by: Simon Rozman --- setupapi/types_windows.go | 15 ++ tun/tun_windows.go | 497 +++++++++++++++++++++++++++++++++++++- tun/ztun_windows.go | 49 ++++ 3 files changed, 556 insertions(+), 5 deletions(-) create mode 100644 tun/ztun_windows.go diff --git a/setupapi/types_windows.go b/setupapi/types_windows.go index db2f8ce..173c32b 100644 --- a/setupapi/types_windows.go +++ b/setupapi/types_windows.go @@ -300,6 +300,21 @@ const ( DICS_FLAG_CONFIGGENERAL DICS_FLAG = 0x00000004 // 1 or more hardware profile-specific changes to follow ) +// DI_REMOVEDEVICE specifies the scope of the device removal +type DI_REMOVEDEVICE uint32 + +const ( + DI_REMOVEDEVICE_GLOBAL DI_REMOVEDEVICE = 0x00000001 // Make this change in all hardware profiles. Remove information about the device from the registry. + DI_REMOVEDEVICE_CONFIGSPECIFIC DI_REMOVEDEVICE = 0x00000002 // Make this change to only the hardware profile specified by HwProfile. this flag only applies to root-enumerated devices. When Windows removes the device from the last hardware profile in which it was configured, Windows performs a global removal. +) + +// SP_REMOVEDEVICE_PARAMS is a structure corresponding to a DIF_REMOVE install function. +type SP_REMOVEDEVICE_PARAMS struct { + ClassInstallHeader SP_CLASSINSTALL_HEADER + Scope DI_REMOVEDEVICE + HwProfile uint32 +} + type SP_DRVINFO_DATA struct { Size uint32 DriverType uint32 diff --git a/tun/tun_windows.go b/tun/tun_windows.go index 0e64155..a6afca7 100644 --- a/tun/tun_windows.go +++ b/tun/tun_windows.go @@ -5,13 +5,20 @@ package tun +//go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output ztun_windows.go tun_windows.go + import ( "errors" "fmt" "os" + "strings" + "syscall" + "time" "unsafe" + "git.zx2c4.com/wireguard-go/setupapi" "golang.org/x/sys/windows" + "golang.org/x/sys/windows/registry" ) const ( @@ -27,6 +34,10 @@ const ( TUN_SIGNAL_MAX = 2 ) +var deviceClassNetGUID = windows.GUID{0x4d36e972, 0xe325, 0x11ce, [8]byte{0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18}} + +const TUN_HWID = "Wintun" + type TunPacket struct { size uint32 data [TUN_MAX_PACKET_SIZE]byte @@ -39,7 +50,7 @@ type TunRWQueue struct { } type nativeTun struct { - ifname string + ifid *windows.GUID tunName string signalName *uint16 tunFile *os.File @@ -52,15 +63,31 @@ type nativeTun struct { } func CreateTUN(ifname string) (TUNDevice, error) { - signalNameUTF16, err := windows.UTF16PtrFromString(fmt.Sprintf("Global\\WINTUN_EVENT_%s", ifname)) + // Does an interface with this name already exist? + ifid, err := getInterface(ifname, 0) + if ifid == nil || err != nil { + // Interface does not exist or an error occured. Create one. + ifid, _, err = createInterface("", 0) + if err != nil { + return nil, err + } + + // Set interface name. (Ignore errors.) + setInterfaceName(ifid, ifname) + } + + ifidStr := guidToString(ifid) + + signalNameUTF16, err := windows.UTF16PtrFromString(fmt.Sprintf("Global\\WINTUN_EVENT_%s", ifidStr)) if err != nil { + deleteInterface(ifid, 0) return nil, err } // Create instance. tun := &nativeTun{ - ifname: ifname, - tunName: fmt.Sprintf("\\\\.\\Global\\WINTUN_DEVICE_%s", ifname), + ifid: ifid, + tunName: fmt.Sprintf("\\\\.\\Global\\WINTUN_DEVICE_%s", ifidStr), signalName: signalNameUTF16, events: make(chan TUNEvent, 10), errors: make(chan error, 1), @@ -69,6 +96,7 @@ func CreateTUN(ifname string) (TUNDevice, error) { // Create close event. tun.signals[TUN_SIGNAL_CLOSE], err = windows.CreateEvent(nil, 1 /*TRUE*/, 0 /*FALSE*/, nil) if err != nil { + deleteInterface(ifid, 0) return nil, err } @@ -132,7 +160,7 @@ func (tun *nativeTun) closeTUN() (err error) { } func (tun *nativeTun) Name() (string, error) { - return tun.ifname, nil + return getInterfaceName(tun.ifid) } func (tun *nativeTun) File() *os.File { @@ -156,6 +184,11 @@ func (tun *nativeTun) Close() error { close(tun.events) } + _, _, e = deleteInterface(tun.ifid, 0) + if err == nil { + err = e + } + return err } @@ -283,3 +316,457 @@ func (tun *nativeTun) Write(buff []byte, offset int) (int, error) { // Flush write buffer. return len(buff) - offset, tun.flush() } + +// +// getInterface finds interface ID by name. +// +// hwndParent is a handle to the top-level window to use for any user +// interface that is related to non-device-specific actions (such as a select- +// device dialog box that uses the global class driver list). This handle is +// optional and can be 0. If a specific top-level window is not required, set +// hwndParent to 0. +// +// Function returns interface ID when the interface was found, or nil +// otherwise. +// +func getInterface(ifname string, hwndParent uintptr) (*windows.GUID, error) { + // Create a list of network devices. + devInfoList, err := setupapi.SetupDiGetClassDevsEx(&deviceClassNetGUID, "", hwndParent, setupapi.DIGCF_PRESENT, setupapi.DevInfo(0), "") + if err != nil { + return nil, err + } + defer devInfoList.Close() + + // Retrieve information associated with a device information set. + // TODO: Is this really necessary? + _, err = devInfoList.GetDeviceInfoListDetail() + if err != nil { + return nil, err + } + + ifname = strings.ToLower(ifname) + + // Iterate. + for index := 0; ; index++ { + // Get the device from the list. + deviceData, err := devInfoList.EnumDeviceInfo(index) + if err != nil { + if errWin, ok := err.(syscall.Errno); ok && errWin == 259 /*ERROR_NO_MORE_ITEMS*/ { + break + } + // Something is wrong with this device. Skip it. + continue + } + + // Get interface ID. + ifid, err := getInterfaceId(devInfoList, deviceData, 1) + if err != nil { + // Something is wrong with this device. Skip it. + continue + } + + // Get interface name. + ifname2, err := getInterfaceName(ifid) + if err != nil { + // Something is wrong with this device. Skip it. + continue + } + + if ifname == strings.ToLower(ifname2) { + // Interface name found. + return ifid, nil + } + } + + return nil, nil +} + +// +// createInterface creates a TUN interface. +// +// description is a string that supplies the text description of the device. +// Description is optional and can be "". +// +// hwndParent is a handle to the top-level window to use for any user +// interface that is related to non-device-specific actions (such as a select- +// device dialog box that uses the global class driver list). This handle is +// optional and can be 0. If a specific top-level window is not required, set +// hwndParent to 0. +// +// Function returns the network interface ID and a flag if reboot is required. +// +func createInterface(description string, hwndParent uintptr) (*windows.GUID, bool, error) { + // Create an empty device info set for network adapter device class. + devInfoList, err := setupapi.SetupDiCreateDeviceInfoListEx(&deviceClassNetGUID, hwndParent, "") + if err != nil { + return nil, false, err + } + + // Get the device class name from GUID. + className, err := setupapi.SetupDiClassNameFromGuidEx(&deviceClassNetGUID, "") + if err != nil { + return nil, false, err + } + + // Create a new device info element and add it to the device info set. + deviceData, err := devInfoList.CreateDeviceInfo(className, &deviceClassNetGUID, description, hwndParent, setupapi.DICD_GENERATE_ID) + if err != nil { + return nil, false, err + } + + // Set a device information element as the selected member of a device information set. + err = devInfoList.SetSelectedDevice(deviceData) + if err != nil { + return nil, false, err + } + + // Set Plug&Play device hardware ID property. + hwid, err := syscall.UTF16FromString(TUN_HWID) + if err != nil { + return nil, false, err + } + err = devInfoList.SetDeviceRegistryProperty(deviceData, setupapi.SPDRP_HARDWAREID, setupapi.UTF16ToBuf(append(hwid, 0))) + if err != nil { + return nil, false, err + } + + // Search for the driver. + const driverType = setupapi.SPDIT_CLASSDRIVER + err = devInfoList.BuildDriverInfoList(deviceData, driverType) + if err != nil { + return nil, false, err + } + defer devInfoList.DestroyDriverInfoList(deviceData, driverType) + + driverDate := windows.Filetime{} + driverVersion := uint64(0) + for index := 0; ; index++ { + // Get a driver from the list. + driverData, err := devInfoList.EnumDriverInfo(deviceData, driverType, index) + if err != nil { + if errWin, ok := err.(syscall.Errno); ok && errWin == 259 /*ERROR_NO_MORE_ITEMS*/ { + break + } + // Something is wrong with this driver. Skip it. + continue + } + + // Check the driver version first, since the check is trivial and will save us iterating over hardware IDs for any driver versioned prior our best match. + if driverData.IsNewer(driverDate, driverVersion) { + // Get driver info details. + driverDetailData, err := devInfoList.GetDriverInfoDetail(deviceData, driverData) + if err != nil { + // Something is wrong with this driver. Skip it. + continue + } + + if driverDetailData.IsCompatible(TUN_HWID) { + // Matching hardware ID found. Select the driver. + err := devInfoList.SetSelectedDriver(deviceData, driverData) + if err != nil { + // Something is wrong with this driver. Skip it. + continue + } + + driverDate = driverData.DriverDate + driverVersion = driverData.DriverVersion + } + } + } + + if driverVersion == 0 { + return nil, false, fmt.Errorf("No driver for device \"%v\" installed", TUN_HWID) + } + + // Call appropriate class installer. + err = devInfoList.CallClassInstaller(setupapi.DIF_REGISTERDEVICE, deviceData) + if err != nil { + return nil, false, err + } + + // Register device co-installers if any. + devInfoList.CallClassInstaller(setupapi.DIF_REGISTER_COINSTALLERS, deviceData) + + // Install interfaces if any. + devInfoList.CallClassInstaller(setupapi.DIF_INSTALLINTERFACES, deviceData) + + var ifid *windows.GUID + var rebootRequired bool + + // Install the device. + err = devInfoList.CallClassInstaller(setupapi.DIF_INSTALLDEVICE, deviceData) + if err == nil { + // Check if a system reboot is required. (Ignore errors) + if ret, _ := checkReboot(devInfoList, deviceData); ret { + rebootRequired = true + } + + // Get network interface ID from registry. Retry for max 30sec. + ifid, err = getInterfaceId(devInfoList, deviceData, 30) + } + + if err == nil { + return ifid, rebootRequired, nil + } + + // The interface failed to install, or the interface ID was unobtainable. Clean-up. + removeDeviceParams := setupapi.SP_REMOVEDEVICE_PARAMS{ + ClassInstallHeader: setupapi.SP_CLASSINSTALL_HEADER{ + InstallFunction: setupapi.DIF_REMOVE, + }, + Scope: setupapi.DI_REMOVEDEVICE_GLOBAL, + } + removeDeviceParams.ClassInstallHeader.Size = uint32(unsafe.Sizeof(removeDeviceParams.ClassInstallHeader)) + + // Set class installer parameters for DIF_REMOVE. + if devInfoList.SetClassInstallParams(deviceData, &removeDeviceParams.ClassInstallHeader, uint32(unsafe.Sizeof(removeDeviceParams))) == nil { + // Call appropriate class installer. + if devInfoList.CallClassInstaller(setupapi.DIF_REMOVE, deviceData) == nil { + // Check if a system reboot is required. (Ignore errors) + if ret, _ := checkReboot(devInfoList, deviceData); ret { + rebootRequired = true + } + } + } + + return nil, false, err +} + +// +// deleteInterface deletes a TUN interface. +// +// hwndParent is a handle to the top-level window to use for any user +// interface that is related to non-device-specific actions (such as a select- +// device dialog box that uses the global class driver list). This handle is +// optional and can be 0. If a specific top-level window is not required, set +// hwndParent to 0. +// +// Function returns true if the interface was found and deleted and a flag if +// reboot is required. +// +func deleteInterface(ifid *windows.GUID, hwndParent uintptr) (bool, bool, error) { + // Create a list of network devices. + devInfoList, err := setupapi.SetupDiGetClassDevsEx(&deviceClassNetGUID, "", hwndParent, setupapi.DIGCF_PRESENT, setupapi.DevInfo(0), "") + if err != nil { + return false, false, err + } + defer devInfoList.Close() + + // Retrieve information associated with a device information set. + // TODO: Is this really necessary? + _, err = devInfoList.GetDeviceInfoListDetail() + if err != nil { + return false, false, err + } + + // Iterate. + for index := 0; ; index++ { + // Get the device from the list. + deviceData, err := devInfoList.EnumDeviceInfo(index) + if err != nil { + if errWin, ok := err.(syscall.Errno); ok && errWin == 259 /*ERROR_NO_MORE_ITEMS*/ { + break + } + // Something is wrong with this device. Skip it. + continue + } + + // Get interface ID. + ifid2, err := getInterfaceId(devInfoList, deviceData, 1) + if err != nil { + // Something is wrong with this device. Skip it. + continue + } + + if ifid == ifid2 { + // Remove the device. + removeDeviceParams := setupapi.SP_REMOVEDEVICE_PARAMS{ + ClassInstallHeader: setupapi.SP_CLASSINSTALL_HEADER{ + InstallFunction: setupapi.DIF_REMOVE, + }, + Scope: setupapi.DI_REMOVEDEVICE_GLOBAL, + } + removeDeviceParams.ClassInstallHeader.Size = uint32(unsafe.Sizeof(removeDeviceParams.ClassInstallHeader)) + + // Set class installer parameters for DIF_REMOVE. + err = devInfoList.SetClassInstallParams(deviceData, &removeDeviceParams.ClassInstallHeader, uint32(unsafe.Sizeof(removeDeviceParams))) + if err != nil { + return false, false, err + } + + // Call appropriate class installer. + err = devInfoList.CallClassInstaller(setupapi.DIF_REMOVE, deviceData) + if err != nil { + return false, false, err + } + + // Check if a system reboot is required. (Ignore errors) + if ret, _ := checkReboot(devInfoList, deviceData); ret { + return true, true, nil + } + + return true, false, nil + } + } + + return false, false, nil +} + +/// +/// checkReboot checks device install parameters if a system reboot is required. +/// +func checkReboot(DeviceInfoSet setupapi.DevInfo, DeviceInfoData *setupapi.SP_DEVINFO_DATA) (bool, error) { + devInstallParams, err := DeviceInfoSet.GetDeviceInstallParams(DeviceInfoData) + if err != nil { + return false, err + } + + if (devInstallParams.Flags & (setupapi.DI_NEEDREBOOT | setupapi.DI_NEEDRESTART)) != 0 { + return true, nil + } + + return false, nil +} + +// getInterfaceId returns network interface ID. +// +// After the device is created, it might take some time before the registry +// key is populated. numAttempts parameter specifies the number of attempts +// to read NetCfgInstanceId value from registry. A 1sec sleep is inserted +// between retry attempts. +// +// Function returns the network interface ID. +// +func getInterfaceId(DeviceInfoSet setupapi.DevInfo, DeviceInfoData *setupapi.SP_DEVINFO_DATA, numAttempts int) (*windows.GUID, error) { + if numAttempts < 1 { + return nil, fmt.Errorf("Invalid numAttempts (expected: >=1, provided: %v)", numAttempts) + } + + // Open HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class\\ registry key. + key, err := DeviceInfoSet.OpenDevRegKey(DeviceInfoData, setupapi.DICS_FLAG_GLOBAL, 0, setupapi.DIREG_DRV, registry.READ) + if err != nil { + return nil, errors.New("Device-specific registry key open failed: " + err.Error()) + } + defer key.Close() + + for { + // Query the NetCfgInstanceId value. Using get_reg_string() right on might clutter the output with error messages while the registry is still being populated. + _, _, err = key.GetValue("NetCfgInstanceId", nil) + if err != nil { + if errWin, ok := err.(syscall.Errno); ok && errWin == windows.ERROR_FILE_NOT_FOUND { + numAttempts-- + if numAttempts > 0 { + // Wait and retry. + // TODO: Wait for a cancellable event instead. + time.Sleep(1000 * time.Millisecond) + continue + } + } + + return nil, errors.New("RegQueryValueEx(\"NetCfgInstanceId\") failed: " + err.Error()) + } + + // Read the NetCfgInstanceId value now. + value, err := getRegStringValue(key, "NetCfgInstanceId") + if err != nil { + return nil, errors.New("RegQueryStringValue(\"NetCfgInstanceId\") failed: " + err.Error()) + } + + // Convert to windows.GUID. + ifid, err := stringToGUID(value) + if err != nil { + return nil, fmt.Errorf("NetCfgInstanceId registry value is not a GUID (expected: \"{...}\", provided: \"%v\")", value) + } + + return ifid, err + } +} + +// +// getInterfaceName returns network interface name. +// +func getInterfaceName(ifid *windows.GUID) (string, error) { + // Open network interface registry key. + key, err := registry.OpenKey(registry.LOCAL_MACHINE, fmt.Sprintf("SYSTEM\\CurrentControlSet\\Control\\Network\\%v\\%v\\Connection", guidToString(&deviceClassNetGUID), guidToString(ifid)), registry.QUERY_VALUE) + if err != nil { + return "", errors.New("Network-specific registry key open failed: " + err.Error()) + } + defer key.Close() + + // Get the interface name. + return getRegStringValue(key, "Name") +} + +// +// setInterfaceName sets network interface name. +// +func setInterfaceName(ifid *windows.GUID, ifname string) error { + // Open network interface registry key. + key, err := registry.OpenKey(registry.LOCAL_MACHINE, fmt.Sprintf("SYSTEM\\CurrentControlSet\\Control\\Network\\%v\\%v\\Connection", guidToString(&deviceClassNetGUID), guidToString(ifid)), registry.SET_VALUE) + if err != nil { + return errors.New("Network-specific registry key open failed: " + err.Error()) + } + defer key.Close() + + // Set the interface name. + return key.SetStringValue("Name", ifname) +} + +//sys clsidFromString(lpsz *uint16, pclsid *windows.GUID) (hr int32) = ole32.CLSIDFromString + +// +// stringToGUID parses "{XXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" string to GUID. +// +func stringToGUID(str string) (*windows.GUID, error) { + strUTF16, err := syscall.UTF16PtrFromString(str) + if err != nil { + return nil, err + } + + guid := &windows.GUID{} + + hr := clsidFromString(strUTF16, guid) + if hr < 0 { + return nil, syscall.Errno(hr) + } + + return guid, nil +} + +// +// guidToString function converts GUID to string +// "{XXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}". +// +// The resulting string is uppercase. +// +func guidToString(guid *windows.GUID) string { + return fmt.Sprintf("{%06X-%04X-%04X-%04X-%012X}", guid.Data1, guid.Data2, guid.Data3, guid.Data4[:2], guid.Data4[2:]) +} + +// +// getRegStringValue function reads a string value from registry. +// +// If the value type is REG_EXPAND_SZ the environment variables are expanded. +// Should expanding fail, original string value and nil error are returned. +// +func getRegStringValue(key registry.Key, name string) (string, error) { + // Read string value. + value, valueType, err := key.GetStringValue(name) + if err != nil { + return "", err + } + + if valueType != registry.EXPAND_SZ { + // Value does not require expansion. + return value, nil + } + + valueExp, err := registry.ExpandString(value) + if err != nil { + // Expanding failed: return original sting value. + return value, nil + } + + // Return expanded value. + return valueExp, nil +} diff --git a/tun/ztun_windows.go b/tun/ztun_windows.go new file mode 100644 index 0000000..9aa6e11 --- /dev/null +++ b/tun/ztun_windows.go @@ -0,0 +1,49 @@ +// Code generated by 'go generate'; DO NOT EDIT. + +package tun + +import ( + "syscall" + "unsafe" + + "golang.org/x/sys/windows" +) + +var _ unsafe.Pointer + +// Do the interface allocations only once for common +// Errno values. +const ( + errnoERROR_IO_PENDING = 997 +) + +var ( + errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING) +) + +// errnoErr returns common boxed Errno values, to prevent +// allocations at runtime. +func errnoErr(e syscall.Errno) error { + switch e { + case 0: + return nil + case errnoERROR_IO_PENDING: + return errERROR_IO_PENDING + } + // TODO: add more here, after collecting data on the common + // error values see on Windows. (perhaps when running + // all.bat?) + return e +} + +var ( + modole32 = windows.NewLazySystemDLL("ole32.dll") + + procCLSIDFromString = modole32.NewProc("CLSIDFromString") +) + +func clsidFromString(lpsz *uint16, pclsid *windows.GUID) (hr int32) { + r0, _, _ := syscall.Syscall(procCLSIDFromString.Addr(), 2, uintptr(unsafe.Pointer(lpsz)), uintptr(unsafe.Pointer(pclsid)), 0) + hr = int32(r0) + return +}