Update dependencies

vendor/tailscale.com/util/osdiag/internal/wsc/wsc_windows.go

@@ -0,0 +1,314 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+// Code generated by 'go generate'; DO NOT EDIT.
+
+// Package wsc provides access to the Windows Security Center API.
+package wsc
+
+import (
+	"runtime"
+	"syscall"
+	"unsafe"
+
+	"github.com/dblohm7/wingoes"
+	"github.com/dblohm7/wingoes/com"
+	"github.com/dblohm7/wingoes/com/automation"
+)
+
+var (
+	CLSID_WSCProductList = &com.CLSID{0x17072F7B, 0x9ABE, 0x4A74, [8]byte{0xA2, 0x61, 0x1E, 0xB7, 0x6B, 0x55, 0x10, 0x7A}}
+)
+
+var (
+	IID_IWSCProductList = &com.IID{0x722A338C, 0x6E8E, 0x4E72, [8]byte{0xAC, 0x27, 0x14, 0x17, 0xFB, 0x0C, 0x81, 0xC2}}
+	IID_IWscProduct     = &com.IID{0x8C38232E, 0x3A45, 0x4A27, [8]byte{0x92, 0xB0, 0x1A, 0x16, 0xA9, 0x75, 0xF6, 0x69}}
+)
+
+type WSC_SECURITY_PRODUCT_STATE int32
+
+const (
+	WSC_SECURITY_PRODUCT_STATE_ON      = WSC_SECURITY_PRODUCT_STATE(0)
+	WSC_SECURITY_PRODUCT_STATE_OFF     = WSC_SECURITY_PRODUCT_STATE(1)
+	WSC_SECURITY_PRODUCT_STATE_SNOOZED = WSC_SECURITY_PRODUCT_STATE(2)
+	WSC_SECURITY_PRODUCT_STATE_EXPIRED = WSC_SECURITY_PRODUCT_STATE(3)
+)
+
+type WSC_SECURITY_SIGNATURE_STATUS int32
+
+const (
+	WSC_SECURITY_PRODUCT_OUT_OF_DATE = WSC_SECURITY_SIGNATURE_STATUS(0)
+	WSC_SECURITY_PRODUCT_UP_TO_DATE  = WSC_SECURITY_SIGNATURE_STATUS(1)
+)
+
+type WSC_SECURITY_PROVIDER int32
+
+const (
+	WSC_SECURITY_PROVIDER_FIREWALL             = WSC_SECURITY_PROVIDER(1)
+	WSC_SECURITY_PROVIDER_AUTOUPDATE_SETTINGS  = WSC_SECURITY_PROVIDER(2)
+	WSC_SECURITY_PROVIDER_ANTIVIRUS            = WSC_SECURITY_PROVIDER(4)
+	WSC_SECURITY_PROVIDER_ANTISPYWARE          = WSC_SECURITY_PROVIDER(8)
+	WSC_SECURITY_PROVIDER_INTERNET_SETTINGS    = WSC_SECURITY_PROVIDER(16)
+	WSC_SECURITY_PROVIDER_USER_ACCOUNT_CONTROL = WSC_SECURITY_PROVIDER(32)
+	WSC_SECURITY_PROVIDER_SERVICE              = WSC_SECURITY_PROVIDER(64)
+	WSC_SECURITY_PROVIDER_NONE                 = WSC_SECURITY_PROVIDER(0)
+	WSC_SECURITY_PROVIDER_ALL                  = WSC_SECURITY_PROVIDER(127)
+)
+
+type SECURITY_PRODUCT_TYPE int32
+
+const (
+	SECURITY_PRODUCT_TYPE_ANTIVIRUS   = SECURITY_PRODUCT_TYPE(0)
+	SECURITY_PRODUCT_TYPE_FIREWALL    = SECURITY_PRODUCT_TYPE(1)
+	SECURITY_PRODUCT_TYPE_ANTISPYWARE = SECURITY_PRODUCT_TYPE(2)
+)
+
+type IWscProductABI struct {
+	com.IUnknownABI // Technically IDispatch, but we're bypassing all of that atm
+}
+
+func (abi *IWscProductABI) GetProductName() (pVal string, err error) {
+	var t0 automation.BSTR
+
+	method := unsafe.Slice(abi.Vtbl, 14)[7]
+	hr, _, _ := syscall.SyscallN(method, uintptr(unsafe.Pointer(abi)), uintptr(unsafe.Pointer(&t0)))
+	if e := wingoes.ErrorFromHRESULT(wingoes.HRESULT(hr)); !e.IsOK() {
+		err = e
+		if e.Failed() {
+			return
+		}
+	}
+
+	pVal = t0.String()
+	t0.Close()
+	return
+}
+
+func (abi *IWscProductABI) GetProductState() (val WSC_SECURITY_PRODUCT_STATE, err error) {
+	method := unsafe.Slice(abi.Vtbl, 14)[8]
+	hr, _, _ := syscall.SyscallN(method, uintptr(unsafe.Pointer(abi)), uintptr(unsafe.Pointer(&val)))
+	if e := wingoes.ErrorFromHRESULT(wingoes.HRESULT(hr)); !e.IsOK() {
+		err = e
+	}
+	return
+}
+
+func (abi *IWscProductABI) GetSignatureStatus() (val WSC_SECURITY_SIGNATURE_STATUS, err error) {
+	method := unsafe.Slice(abi.Vtbl, 14)[9]
+	hr, _, _ := syscall.SyscallN(method, uintptr(unsafe.Pointer(abi)), uintptr(unsafe.Pointer(&val)))
+	if e := wingoes.ErrorFromHRESULT(wingoes.HRESULT(hr)); !e.IsOK() {
+		err = e
+	}
+	return
+}
+
+func (abi *IWscProductABI) GetRemediationPath() (pVal string, err error) {
+	var t0 automation.BSTR
+
+	method := unsafe.Slice(abi.Vtbl, 14)[10]
+	hr, _, _ := syscall.SyscallN(method, uintptr(unsafe.Pointer(abi)), uintptr(unsafe.Pointer(&t0)))
+	if e := wingoes.ErrorFromHRESULT(wingoes.HRESULT(hr)); !e.IsOK() {
+		err = e
+		if e.Failed() {
+			return
+		}
+	}
+
+	pVal = t0.String()
+	t0.Close()
+	return
+}
+
+func (abi *IWscProductABI) GetProductStateTimestamp() (pVal string, err error) {
+	var t0 automation.BSTR
+
+	method := unsafe.Slice(abi.Vtbl, 14)[11]
+	hr, _, _ := syscall.SyscallN(method, uintptr(unsafe.Pointer(abi)), uintptr(unsafe.Pointer(&t0)))
+	if e := wingoes.ErrorFromHRESULT(wingoes.HRESULT(hr)); !e.IsOK() {
+		err = e
+		if e.Failed() {
+			return
+		}
+	}
+
+	pVal = t0.String()
+	t0.Close()
+	return
+}
+
+func (abi *IWscProductABI) GetProductGuid() (pVal string, err error) {
+	var t0 automation.BSTR
+
+	method := unsafe.Slice(abi.Vtbl, 14)[12]
+	hr, _, _ := syscall.SyscallN(method, uintptr(unsafe.Pointer(abi)), uintptr(unsafe.Pointer(&t0)))
+	if e := wingoes.ErrorFromHRESULT(wingoes.HRESULT(hr)); !e.IsOK() {
+		err = e
+		if e.Failed() {
+			return
+		}
+	}
+
+	pVal = t0.String()
+	t0.Close()
+	return
+}
+
+func (abi *IWscProductABI) GetProductIsDefault() (pVal bool, err error) {
+	var t0 int32
+
+	method := unsafe.Slice(abi.Vtbl, 14)[13]
+	hr, _, _ := syscall.SyscallN(method, uintptr(unsafe.Pointer(abi)), uintptr(unsafe.Pointer(&t0)))
+	if e := wingoes.ErrorFromHRESULT(wingoes.HRESULT(hr)); !e.IsOK() {
+		err = e
+		if e.Failed() {
+			return
+		}
+	}
+
+	pVal = t0 != 0
+	return
+}
+
+type WscProduct struct {
+	com.GenericObject[IWscProductABI]
+}
+
+func (o WscProduct) GetProductName() (pVal string, err error) {
+	p := *(o.Pp)
+	return p.GetProductName()
+}
+
+func (o WscProduct) GetProductState() (val WSC_SECURITY_PRODUCT_STATE, err error) {
+	p := *(o.Pp)
+	return p.GetProductState()
+}
+
+func (o WscProduct) GetSignatureStatus() (val WSC_SECURITY_SIGNATURE_STATUS, err error) {
+	p := *(o.Pp)
+	return p.GetSignatureStatus()
+}
+
+func (o WscProduct) GetRemediationPath() (pVal string, err error) {
+	p := *(o.Pp)
+	return p.GetRemediationPath()
+}
+
+func (o WscProduct) GetProductStateTimestamp() (pVal string, err error) {
+	p := *(o.Pp)
+	return p.GetProductStateTimestamp()
+}
+
+func (o WscProduct) GetProductGuid() (pVal string, err error) {
+	p := *(o.Pp)
+	return p.GetProductGuid()
+}
+
+func (o WscProduct) GetProductIsDefault() (pVal bool, err error) {
+	p := *(o.Pp)
+	return p.GetProductIsDefault()
+}
+
+func (o WscProduct) IID() *com.IID {
+	return IID_IWscProduct
+}
+
+func (o WscProduct) Make(r com.ABIReceiver) any {
+	if r == nil {
+		return WscProduct{}
+	}
+
+	runtime.SetFinalizer(r, com.ReleaseABI)
+
+	pp := (**IWscProductABI)(unsafe.Pointer(r))
+	return WscProduct{com.GenericObject[IWscProductABI]{Pp: pp}}
+}
+
+func (o WscProduct) MakeFromKnownABI(r **IWscProductABI) WscProduct {
+	if r == nil {
+		return WscProduct{}
+	}
+
+	runtime.SetFinalizer(r, func(r **IWscProductABI) { (*r).Release() })
+	return WscProduct{com.GenericObject[IWscProductABI]{Pp: r}}
+}
+
+func (o WscProduct) UnsafeUnwrap() *IWscProductABI {
+	return *(o.Pp)
+}
+
+type IWSCProductListABI struct {
+	com.IUnknownABI // Technically IDispatch, but we're bypassing all of that atm
+}
+
+func (abi *IWSCProductListABI) Initialize(provider WSC_SECURITY_PROVIDER) (err error) {
+	method := unsafe.Slice(abi.Vtbl, 10)[7]
+	hr, _, _ := syscall.SyscallN(method, uintptr(unsafe.Pointer(abi)), uintptr(provider))
+	if e := wingoes.ErrorFromHRESULT(wingoes.HRESULT(hr)); !e.IsOK() {
+		err = e
+	}
+	return
+}
+
+func (abi *IWSCProductListABI) GetCount() (val int32, err error) {
+	method := unsafe.Slice(abi.Vtbl, 10)[8]
+	hr, _, _ := syscall.SyscallN(method, uintptr(unsafe.Pointer(abi)), uintptr(unsafe.Pointer(&val)))
+	if e := wingoes.ErrorFromHRESULT(wingoes.HRESULT(hr)); !e.IsOK() {
+		err = e
+	}
+	return
+}
+
+func (abi *IWSCProductListABI) GetItem(index uint32) (val WscProduct, err error) {
+	var t0 *IWscProductABI
+
+	method := unsafe.Slice(abi.Vtbl, 10)[9]
+	hr, _, _ := syscall.SyscallN(method, uintptr(unsafe.Pointer(abi)), uintptr(index), uintptr(unsafe.Pointer(&t0)))
+	if e := wingoes.ErrorFromHRESULT(wingoes.HRESULT(hr)); !e.IsOK() {
+		err = e
+		if e.Failed() {
+			return
+		}
+	}
+
+	var r0 WscProduct
+	val = r0.MakeFromKnownABI(&t0)
+	return
+}
+
+type WSCProductList struct {
+	com.GenericObject[IWSCProductListABI]
+}
+
+func (o WSCProductList) Initialize(provider WSC_SECURITY_PROVIDER) (err error) {
+	p := *(o.Pp)
+	return p.Initialize(provider)
+}
+
+func (o WSCProductList) GetCount() (val int32, err error) {
+	p := *(o.Pp)
+	return p.GetCount()
+}
+
+func (o WSCProductList) GetItem(index uint32) (val WscProduct, err error) {
+	p := *(o.Pp)
+	return p.GetItem(index)
+}
+
+func (o WSCProductList) IID() *com.IID {
+	return IID_IWSCProductList
+}
+
+func (o WSCProductList) Make(r com.ABIReceiver) any {
+	if r == nil {
+		return WSCProductList{}
+	}
+
+	runtime.SetFinalizer(r, com.ReleaseABI)
+
+	pp := (**IWSCProductListABI)(unsafe.Pointer(r))
+	return WSCProductList{com.GenericObject[IWSCProductListABI]{Pp: pp}}
+}
+
+func (o WSCProductList) UnsafeUnwrap() *IWSCProductListABI {
+	return *(o.Pp)
+}

vendor/tailscale.com/util/osdiag/mksyscall.go

@@ -0,0 +1,13 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+package osdiag
+
+//go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go mksyscall.go
+//go:generate go run golang.org/x/tools/cmd/goimports -w zsyscall_windows.go
+
+//sys globalMemoryStatusEx(memStatus *_MEMORYSTATUSEX) (err error) [int32(failretval)==0] = kernel32.GlobalMemoryStatusEx
+//sys regEnumValue(key registry.Key, index uint32, valueName *uint16, valueNameLen *uint32, reserved *uint32, valueType *uint32, pData *byte, cbData *uint32) (ret error) [failretval!=0] = advapi32.RegEnumValueW
+//sys wscEnumProtocols(iProtocols *int32, protocolBuffer *wsaProtocolInfo, bufLen *uint32, errno *int32) (ret int32) = ws2_32.WSCEnumProtocols
+//sys wscGetProviderInfo(providerId *windows.GUID, infoType _WSC_PROVIDER_INFO_TYPE, info unsafe.Pointer, infoSize *uintptr, flags uint32, errno *int32) (ret int32) = ws2_32.WSCGetProviderInfo
+//sys wscGetProviderPath(providerId *windows.GUID, providerDllPath *uint16, providerDllPathLen *int32, errno *int32) (ret int32) = ws2_32.WSCGetProviderPath

vendor/tailscale.com/util/osdiag/osdiag.go

@@ -0,0 +1,20 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+// Package osdiag provides loggers for OS-specific diagnostic information.
+package osdiag
+
+// LogSupportInfoReason is an enumeration indicating the reason for logging
+// support info.
+type LogSupportInfoReason int
+
+const (
+	LogSupportInfoReasonStartup   LogSupportInfoReason = iota + 1 // tailscaled is starting up.
+	LogSupportInfoReasonBugReport                                 // a bugreport is in the process of being gathered.
+)
+
+// SupportInfo obtains OS-specific diagnostic information for troubleshooting
+// and support. The reason governs the verbosity of the output.
+func SupportInfo(reason LogSupportInfoReason) map[string]any {
+	return supportInfo(reason)
+}

vendor/tailscale.com/util/osdiag/osdiag_notwindows.go

@@ -0,0 +1,10 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+//go:build !windows
+
+package osdiag
+
+func supportInfo(LogSupportInfoReason) map[string]any {
+	return nil
+}

vendor/tailscale.com/util/osdiag/osdiag_windows.go

@@ -0,0 +1,655 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+package osdiag
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strings"
+	"unicode/utf16"
+	"unsafe"
+
+	"github.com/dblohm7/wingoes/com"
+	"github.com/dblohm7/wingoes/pe"
+	"golang.org/x/sys/windows"
+	"golang.org/x/sys/windows/registry"
+	"tailscale.com/util/osdiag/internal/wsc"
+	"tailscale.com/util/winutil"
+	"tailscale.com/util/winutil/authenticode"
+)
+
+var (
+	errUnexpectedResult = errors.New("API call returned an unexpected value")
+)
+
+const (
+	maxBinaryValueLen  = 128   // we'll truncate any binary values longer than this
+	maxRegValueNameLen = 16384 // maximum length supported by Windows + 1
+	initialValueBufLen = 80    // large enough to contain a stringified GUID encoded as UTF-16
+)
+
+const (
+	supportInfoKeyModules    = "modules"
+	supportInfoKeyPageFile   = "pageFile"
+	supportInfoKeyRegistry   = "registry"
+	supportInfoKeySecurity   = "securitySoftware"
+	supportInfoKeyWinsockLSP = "winsockLSP"
+)
+
+func supportInfo(reason LogSupportInfoReason) map[string]any {
+	output := make(map[string]any)
+
+	regInfo, err := getRegistrySupportInfo(registry.LOCAL_MACHINE, []string{winutil.RegPolicyBase, winutil.RegBase})
+	if err == nil {
+		output[supportInfoKeyRegistry] = regInfo
+	} else {
+		output[supportInfoKeyRegistry] = err
+	}
+
+	pageFileInfo, err := getPageFileInfo()
+	if err == nil {
+		output[supportInfoKeyPageFile] = pageFileInfo
+	} else {
+		output[supportInfoKeyPageFile] = err
+	}
+
+	if reason == LogSupportInfoReasonBugReport {
+		modInfo, err := getModuleInfo()
+		if err == nil {
+			output[supportInfoKeyModules] = modInfo
+		} else {
+			output[supportInfoKeyModules] = err
+		}
+
+		output[supportInfoKeySecurity] = getSecurityInfo()
+
+		lspInfo, err := getWinsockLSPInfo()
+		if err == nil {
+			output[supportInfoKeyWinsockLSP] = lspInfo
+		} else {
+			output[supportInfoKeyWinsockLSP] = err
+		}
+	}
+
+	return output
+}
+
+type getRegistrySupportInfoBufs struct {
+	nameBuf  []uint16
+	valueBuf []byte
+}
+
+func getRegistrySupportInfo(root registry.Key, subKeys []string) (map[string]any, error) {
+	bufs := getRegistrySupportInfoBufs{
+		nameBuf:  make([]uint16, maxRegValueNameLen),
+		valueBuf: make([]byte, initialValueBufLen),
+	}
+
+	output := make(map[string]any)
+
+	for _, subKey := range subKeys {
+		if err := getRegSubKey(root, subKey, 5, &bufs, output); err != nil && !errors.Is(err, registry.ErrNotExist) {
+			return nil, fmt.Errorf("getRegistrySupportInfo: %w", err)
+		}
+	}
+
+	return output, nil
+}
+
+func keyString(key registry.Key, subKey string) string {
+	var keyStr string
+	switch key {
+	case registry.CLASSES_ROOT:
+		keyStr = `HKCR\`
+	case registry.CURRENT_USER:
+		keyStr = `HKCU\`
+	case registry.LOCAL_MACHINE:
+		keyStr = `HKLM\`
+	case registry.USERS:
+		keyStr = `HKU\`
+	case registry.CURRENT_CONFIG:
+		keyStr = `HKCC\`
+	case registry.PERFORMANCE_DATA:
+		keyStr = `HKPD\`
+	default:
+	}
+
+	return keyStr + subKey
+}
+
+func getRegSubKey(key registry.Key, subKey string, recursionLimit int, bufs *getRegistrySupportInfoBufs, output map[string]any) error {
+	keyStr := keyString(key, subKey)
+	k, err := registry.OpenKey(key, subKey, registry.READ)
+	if err != nil {
+		return fmt.Errorf("opening %q: %w", keyStr, err)
+	}
+	defer k.Close()
+
+	kv := make(map[string]any)
+	index := uint32(0)
+
+loopValues:
+	for {
+		nbuf := bufs.nameBuf
+		nameLen := uint32(len(nbuf))
+		valueType := uint32(0)
+		vbuf := bufs.valueBuf
+		valueLen := uint32(len(vbuf))
+
+		err := regEnumValue(k, index, &nbuf[0], &nameLen, nil, &valueType, &vbuf[0], &valueLen)
+		switch err {
+		case windows.ERROR_NO_MORE_ITEMS:
+			break loopValues
+		case windows.ERROR_MORE_DATA:
+			bufs.valueBuf = make([]byte, valueLen)
+			continue
+		case nil:
+		default:
+			return fmt.Errorf("regEnumValue: %w", err)
+		}
+
+		var value any
+
+		switch valueType {
+		case registry.SZ, registry.EXPAND_SZ:
+			value = windows.UTF16PtrToString((*uint16)(unsafe.Pointer(&vbuf[0])))
+		case registry.BINARY:
+			if valueLen > maxBinaryValueLen {
+				valueLen = maxBinaryValueLen
+			}
+			value = append([]byte{}, vbuf[:valueLen]...)
+		case registry.DWORD:
+			value = binary.LittleEndian.Uint32(vbuf[:4])
+		case registry.MULTI_SZ:
+			// Adapted from x/sys/windows/registry/(Key).GetStringsValue
+			p := (*[1 << 29]uint16)(unsafe.Pointer(&vbuf[0]))[: valueLen/2 : valueLen/2]
+			var strs []string
+			if len(p) > 0 {
+				if p[len(p)-1] == 0 {
+					p = p[:len(p)-1]
+				}
+				strs = make([]string, 0, 5)
+				from := 0
+				for i, c := range p {
+					if c == 0 {
+						strs = append(strs, string(utf16.Decode(p[from:i])))
+						from = i + 1
+					}
+				}
+			}
+			value = strs
+		case registry.QWORD:
+			value = binary.LittleEndian.Uint64(vbuf[:8])
+		default:
+			value = fmt.Sprintf("<unsupported value type %d>", valueType)
+		}
+
+		kv[windows.UTF16PtrToString(&nbuf[0])] = value
+		index++
+	}
+
+	if recursionLimit > 0 {
+		if sks, err := k.ReadSubKeyNames(0); err == nil {
+			for _, sk := range sks {
+				if err := getRegSubKey(k, sk, recursionLimit-1, bufs, kv); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	output[keyStr] = kv
+	return nil
+}
+
+type moduleInfo struct {
+	path         string            `json:"-"` // internal use only
+	BaseAddress  uintptr           `json:"baseAddress"`
+	Size         uint32            `json:"size"`
+	DebugInfo    map[string]string `json:"debugInfo,omitempty"` // map for JSON marshaling purposes
+	DebugInfoErr error             `json:"debugInfoErr,omitempty"`
+	Signature    map[string]string `json:"signature,omitempty"` // map for JSON marshaling purposes
+	SignatureErr error             `json:"signatureErr,omitempty"`
+	VersionInfo  map[string]string `json:"versionInfo,omitempty"` // map for JSON marshaling purposes
+	VersionErr   error             `json:"versionErr,omitempty"`
+}
+
+func (mi *moduleInfo) setVersionInfo() {
+	vi, err := pe.NewVersionInfo(mi.path)
+	if err != nil {
+		if !errors.Is(err, pe.ErrNotPresent) {
+			mi.VersionErr = err
+		}
+		return
+	}
+
+	info := map[string]string{
+		"": vi.VersionNumber().String(),
+	}
+
+	ci, err := vi.Field("CompanyName")
+	if err == nil {
+		info["companyName"] = ci
+	}
+
+	mi.VersionInfo = info
+}
+
+var errAssertingType = errors.New("asserting DataDirectory type")
+
+func (mi *moduleInfo) setDebugInfo() {
+	pem, err := pe.NewPEFromBaseAddressAndSize(mi.BaseAddress, mi.Size)
+	if err != nil {
+		mi.DebugInfoErr = err
+		return
+	}
+	defer pem.Close()
+
+	debugDirAny, err := pem.DataDirectoryEntry(pe.IMAGE_DIRECTORY_ENTRY_DEBUG)
+	if err != nil {
+		if !errors.Is(err, pe.ErrNotPresent) {
+			mi.DebugInfoErr = err
+		}
+		return
+	}
+
+	debugDir, ok := debugDirAny.([]pe.IMAGE_DEBUG_DIRECTORY)
+	if !ok {
+		mi.DebugInfoErr = errAssertingType
+		return
+	}
+
+	for _, dde := range debugDir {
+		if dde.Type != pe.IMAGE_DEBUG_TYPE_CODEVIEW {
+			continue
+		}
+
+		cv, err := pem.ExtractCodeViewInfo(dde)
+		if err == nil {
+			mi.DebugInfo = map[string]string{
+				"id":  cv.String(),
+				"pdb": strings.ToLower(filepath.Base(cv.PDBPath)),
+			}
+		} else {
+			mi.DebugInfoErr = err
+		}
+
+		return
+	}
+}
+
+func (mi *moduleInfo) setAuthenticodeInfo() {
+	certSubject, provenance, err := authenticode.QueryCertSubject(mi.path)
+	if err != nil {
+		if !errors.Is(err, authenticode.ErrSigNotFound) {
+			mi.SignatureErr = err
+		}
+		return
+	}
+
+	sigInfo := map[string]string{
+		"subject": certSubject,
+	}
+
+	switch provenance {
+	case authenticode.SigProvEmbedded:
+		sigInfo["provenance"] = "embedded"
+	case authenticode.SigProvCatalog:
+		sigInfo["provenance"] = "catalog"
+	default:
+	}
+
+	mi.Signature = sigInfo
+}
+
+func getModuleInfo() (map[string]moduleInfo, error) {
+	// Take a snapshot of all modules currently loaded into the current process
+	snap, err := windows.CreateToolhelp32Snapshot(windows.TH32CS_SNAPMODULE, 0)
+	if err != nil {
+		return nil, err
+	}
+	defer windows.CloseHandle(snap)
+
+	result := make(map[string]moduleInfo)
+	me := windows.ModuleEntry32{
+		Size: uint32(unsafe.Sizeof(windows.ModuleEntry32{})),
+	}
+
+	// Now walk the list
+	for merr := windows.Module32First(snap, &me); merr == nil; merr = windows.Module32Next(snap, &me) {
+		name := strings.ToLower(windows.UTF16ToString(me.Module[:]))
+		path := windows.UTF16ToString(me.ExePath[:])
+		base := me.ModBaseAddr
+		size := me.ModBaseSize
+
+		entry := moduleInfo{
+			path:        path,
+			BaseAddress: base,
+			Size:        size,
+		}
+
+		entry.setVersionInfo()
+		entry.setDebugInfo()
+		entry.setAuthenticodeInfo()
+
+		result[name] = entry
+	}
+
+	return result, nil
+}
+
+type _WSC_PROVIDER_INFO_TYPE int32
+
+const (
+	providerInfoLspCategories _WSC_PROVIDER_INFO_TYPE = 0
+)
+
+const (
+	_SOCKET_ERROR = -1
+)
+
+// Note that wsaProtocolInfo needs to be identical to windows.WSAProtocolInfo;
+// the purpose of this type is to have the ability to use it as a reciever in
+// the path and categoryFlags funcs defined below.
+type wsaProtocolInfo windows.WSAProtocolInfo
+
+func (pi *wsaProtocolInfo) path() (string, error) {
+	var errno int32
+	var buf [windows.MAX_PATH]uint16
+	bufCount := int32(len(buf))
+	ret := wscGetProviderPath(&pi.ProviderId, &buf[0], &bufCount, &errno)
+	if ret == _SOCKET_ERROR {
+		return "", windows.Errno(errno)
+	}
+	if ret != 0 {
+		return "", errUnexpectedResult
+	}
+
+	return windows.UTF16ToString(buf[:bufCount]), nil
+}
+
+func (pi *wsaProtocolInfo) categoryFlags() (uint32, error) {
+	var errno int32
+	var result uint32
+	bufLen := uintptr(unsafe.Sizeof(result))
+	ret := wscGetProviderInfo(&pi.ProviderId, providerInfoLspCategories, unsafe.Pointer(&result), &bufLen, 0, &errno)
+	if ret == _SOCKET_ERROR {
+		return 0, windows.Errno(errno)
+	}
+	if ret != 0 {
+		return 0, errUnexpectedResult
+	}
+
+	return result, nil
+}
+
+type wsaProtocolInfoOutput struct {
+	Description     string   `json:"description,omitempty"`
+	Version         int32    `json:"version"`
+	AddressFamily   int32    `json:"addressFamily"`
+	SocketType      int32    `json:"socketType"`
+	Protocol        int32    `json:"protocol"`
+	ServiceFlags1   string   `json:"serviceFlags1"`
+	ProviderFlags   string   `json:"providerFlags"`
+	Path            string   `json:"path,omitempty"`
+	PathErr         error    `json:"pathErr,omitempty"`
+	Category        string   `json:"category,omitempty"`
+	CategoryErr     error    `json:"categoryErr,omitempty"`
+	BaseProviderID  string   `json:"baseProviderID,omitempty"`
+	LayerProviderID string   `json:"layerProviderID,omitempty"`
+	Chain           []uint32 `json:"chain,omitempty"`
+}
+
+func getWinsockLSPInfo() (map[uint32]wsaProtocolInfoOutput, error) {
+	protocols, err := enumWinsockProtocols()
+	if err != nil {
+		return nil, err
+	}
+
+	result := make(map[uint32]wsaProtocolInfoOutput, len(protocols))
+	for _, p := range protocols {
+		v := wsaProtocolInfoOutput{
+			Description:   windows.UTF16ToString(p.ProtocolName[:]),
+			Version:       p.Version,
+			AddressFamily: p.AddressFamily,
+			SocketType:    p.SocketType,
+			Protocol:      p.Protocol,
+			ServiceFlags1: fmt.Sprintf("0x%08X", p.ServiceFlags1), // Serializing as hex string to make the flags easier to decode by human inspection
+			ProviderFlags: fmt.Sprintf("0x%08X", p.ProviderFlags),
+		}
+
+		switch p.ProtocolChain.ChainLen {
+		case windows.BASE_PROTOCOL:
+			v.BaseProviderID = p.ProviderId.String()
+		case windows.LAYERED_PROTOCOL:
+			v.LayerProviderID = p.ProviderId.String()
+		default:
+			v.Chain = p.ProtocolChain.ChainEntries[:p.ProtocolChain.ChainLen]
+		}
+
+		// Queries that are only valid for base and layered protocols (not chains)
+		if v.Chain == nil {
+			path, err := p.path()
+			if err == nil {
+				v.Path = strings.ToLower(path)
+			} else {
+				v.PathErr = err
+			}
+
+			category, err := p.categoryFlags()
+			if err == nil {
+				v.Category = fmt.Sprintf("0x%08X", category)
+			} else if !errors.Is(err, windows.WSAEINVALIDPROVIDER) {
+				// WSAEINVALIDPROVIDER == "no category info found", so we only log
+				// errors other than that one.
+				v.CategoryErr = err
+			}
+		}
+
+		// Chains reference other providers using catalog entry IDs, so we use that
+		// value as the key in our map.
+		result[p.CatalogEntryId] = v
+	}
+
+	return result, nil
+}
+
+func enumWinsockProtocols() ([]wsaProtocolInfo, error) {
+	// Get the required size
+	var errno int32
+	var bytesReqd uint32
+	ret := wscEnumProtocols(nil, nil, &bytesReqd, &errno)
+	if ret != _SOCKET_ERROR {
+		return nil, errUnexpectedResult
+	}
+	if e := windows.Errno(errno); e != windows.WSAENOBUFS {
+		return nil, e
+	}
+
+	// Allocate
+	szEntry := uint32(unsafe.Sizeof(wsaProtocolInfo{}))
+	buf := make([]wsaProtocolInfo, bytesReqd/szEntry)
+
+	// Now do the query for real
+	bufLen := uint32(len(buf)) * szEntry
+	ret = wscEnumProtocols(nil, &buf[0], &bufLen, &errno)
+	if ret == _SOCKET_ERROR {
+		return nil, windows.Errno(errno)
+	}
+
+	return buf, nil
+}
+
+type providerKey struct {
+	provType wsc.WSC_SECURITY_PROVIDER
+	provKey  string
+}
+
+var providerKeys = []providerKey{
+	providerKey{
+		wsc.WSC_SECURITY_PROVIDER_ANTIVIRUS,
+		"av",
+	},
+	providerKey{
+		wsc.WSC_SECURITY_PROVIDER_ANTISPYWARE,
+		"antispy",
+	},
+	providerKey{
+		wsc.WSC_SECURITY_PROVIDER_FIREWALL,
+		"firewall",
+	},
+}
+
+const (
+	maxProvCount = 100
+)
+
+type secProductInfo struct {
+	Name     string `json:"name,omitempty"`
+	NameErr  error  `json:"nameErr,omitempty"`
+	State    string `json:"state,omitempty"`
+	StateErr error  `json:"stateErr,omitempty"`
+}
+
+func getSecurityInfo() map[string]any {
+	result := make(map[string]any)
+
+	for _, prov := range providerKeys {
+		// Note that we need to obtain a new product list for each provider type;
+		// the docs clearly state that we cannot reuse objects.
+		productList, err := com.CreateInstance[wsc.WSCProductList](wsc.CLSID_WSCProductList)
+		if err != nil {
+			result[prov.provKey] = err
+			continue
+		}
+
+		err = productList.Initialize(prov.provType)
+		if err != nil {
+			result[prov.provKey] = err
+			continue
+		}
+
+		n, err := productList.GetCount()
+		if err != nil {
+			result[prov.provKey] = err
+			continue
+		}
+		if n == 0 {
+			continue
+		}
+
+		n = min(n, maxProvCount)
+		values := make([]any, 0, n)
+
+		for i := int32(0); i < n; i++ {
+			product, err := productList.GetItem(uint32(i))
+			if err != nil {
+				values = append(values, err)
+				continue
+			}
+
+			var value secProductInfo
+
+			value.Name, err = product.GetProductName()
+			if err != nil {
+				value.NameErr = err
+			}
+
+			state, err := product.GetProductState()
+			if err == nil {
+				switch state {
+				case wsc.WSC_SECURITY_PRODUCT_STATE_ON:
+					value.State = "on"
+				case wsc.WSC_SECURITY_PRODUCT_STATE_OFF:
+					value.State = "off"
+				case wsc.WSC_SECURITY_PRODUCT_STATE_SNOOZED:
+					value.State = "snoozed"
+				case wsc.WSC_SECURITY_PRODUCT_STATE_EXPIRED:
+					value.State = "expired"
+				default:
+					value.State = fmt.Sprintf("<unknown state value %d>", state)
+				}
+			} else {
+				value.StateErr = err
+			}
+
+			values = append(values, value)
+		}
+
+		result[prov.provKey] = values
+	}
+
+	return result
+}
+
+type _MEMORYSTATUSEX struct {
+	Length               uint32
+	MemoryLoad           uint32
+	TotalPhys            uint64
+	AvailPhys            uint64
+	TotalPageFile        uint64
+	AvailPageFile        uint64
+	TotalVirtual         uint64
+	AvailVirtual         uint64
+	AvailExtendedVirtual uint64
+}
+
+func getPageFileInfo() (map[string]any, error) {
+	memStatus := _MEMORYSTATUSEX{
+		Length: uint32(unsafe.Sizeof(_MEMORYSTATUSEX{})),
+	}
+	if err := globalMemoryStatusEx(&memStatus); err != nil {
+		return nil, err
+	}
+
+	result := map[string]any{
+		"bytesAvailable": memStatus.AvailPageFile,
+		"bytesTotal":     memStatus.TotalPageFile,
+	}
+
+	if entries, err := getEffectivePageFileValue(); err == nil {
+		// autoManaged is set to true when there is at least one page file that
+		// is automatically managed.
+		autoManaged := false
+
+		// If there is only one entry that consists of only one part, then
+		// the page files are 100% managed by the system.
+		// If there are multiple entries, then each one must be checked.
+		// Each entry then consists of three components, deliminated by spaces.
+		// If the latter two components are both "0", then that entry is auto-managed.
+		for _, entry := range entries {
+			if parts := strings.Split(entry, " "); (len(parts) == 1 && len(entries) == 1) ||
+				(len(parts) == 3 && parts[1] == "0" && parts[2] == "0") {
+				autoManaged = true
+				break
+			}
+		}
+
+		result["autoManaged"] = autoManaged
+	}
+
+	return result, nil
+}
+
+func getEffectivePageFileValue() ([]string, error) {
+	const subKey = `SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management`
+	key, err := registry.OpenKey(registry.LOCAL_MACHINE, subKey, registry.QUERY_VALUE)
+	if err != nil {
+		return nil, err
+	}
+	defer key.Close()
+
+	// Rare but possible case: the user has updated their page file config but
+	// they haven't yet rebooted for the change to take effect. This is the
+	// current setting that the machine is still operating with.
+	if entries, _, err := key.GetStringsValue("ExistingPageFiles"); err == nil {
+		return entries, nil
+	}
+
+	// Otherwise we use this value (yes, the above value uses "Page" and this one uses "Paging").
+	entries, _, err := key.GetStringsValue("PagingFiles")
+	return entries, err
+}

vendor/tailscale.com/util/osdiag/zsyscall_windows.go

@@ -0,0 +1,85 @@
+// Code generated by 'go generate'; DO NOT EDIT.
+
+package osdiag
+
+import (
+	"syscall"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+	"golang.org/x/sys/windows/registry"
+)
+
+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)
+	errERROR_EINVAL     error = syscall.EINVAL
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e syscall.Errno) error {
+	switch e {
+	case 0:
+		return errERROR_EINVAL
+	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 (
+	modadvapi32 = windows.NewLazySystemDLL("advapi32.dll")
+	modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
+	modws2_32   = windows.NewLazySystemDLL("ws2_32.dll")
+
+	procRegEnumValueW        = modadvapi32.NewProc("RegEnumValueW")
+	procGlobalMemoryStatusEx = modkernel32.NewProc("GlobalMemoryStatusEx")
+	procWSCEnumProtocols     = modws2_32.NewProc("WSCEnumProtocols")
+	procWSCGetProviderInfo   = modws2_32.NewProc("WSCGetProviderInfo")
+	procWSCGetProviderPath   = modws2_32.NewProc("WSCGetProviderPath")
+)
+
+func regEnumValue(key registry.Key, index uint32, valueName *uint16, valueNameLen *uint32, reserved *uint32, valueType *uint32, pData *byte, cbData *uint32) (ret error) {
+	r0, _, _ := syscall.Syscall9(procRegEnumValueW.Addr(), 8, uintptr(key), uintptr(index), uintptr(unsafe.Pointer(valueName)), uintptr(unsafe.Pointer(valueNameLen)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(valueType)), uintptr(unsafe.Pointer(pData)), uintptr(unsafe.Pointer(cbData)), 0)
+	if r0 != 0 {
+		ret = syscall.Errno(r0)
+	}
+	return
+}
+
+func globalMemoryStatusEx(memStatus *_MEMORYSTATUSEX) (err error) {
+	r1, _, e1 := syscall.Syscall(procGlobalMemoryStatusEx.Addr(), 1, uintptr(unsafe.Pointer(memStatus)), 0, 0)
+	if int32(r1) == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+func wscEnumProtocols(iProtocols *int32, protocolBuffer *wsaProtocolInfo, bufLen *uint32, errno *int32) (ret int32) {
+	r0, _, _ := syscall.Syscall6(procWSCEnumProtocols.Addr(), 4, uintptr(unsafe.Pointer(iProtocols)), uintptr(unsafe.Pointer(protocolBuffer)), uintptr(unsafe.Pointer(bufLen)), uintptr(unsafe.Pointer(errno)), 0, 0)
+	ret = int32(r0)
+	return
+}
+
+func wscGetProviderInfo(providerId *windows.GUID, infoType _WSC_PROVIDER_INFO_TYPE, info unsafe.Pointer, infoSize *uintptr, flags uint32, errno *int32) (ret int32) {
+	r0, _, _ := syscall.Syscall6(procWSCGetProviderInfo.Addr(), 6, uintptr(unsafe.Pointer(providerId)), uintptr(infoType), uintptr(info), uintptr(unsafe.Pointer(infoSize)), uintptr(flags), uintptr(unsafe.Pointer(errno)))
+	ret = int32(r0)
+	return
+}
+
+func wscGetProviderPath(providerId *windows.GUID, providerDllPath *uint16, providerDllPathLen *int32, errno *int32) (ret int32) {
+	r0, _, _ := syscall.Syscall6(procWSCGetProviderPath.Addr(), 4, uintptr(unsafe.Pointer(providerId)), uintptr(unsafe.Pointer(providerDllPath)), uintptr(unsafe.Pointer(providerDllPathLen)), uintptr(unsafe.Pointer(errno)), 0, 0)
+	ret = int32(r0)
+	return
+}