openfact 5.0.0.rc0

data/lib/facter/resolvers/windows/ffi/ffi.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+FFI.typedef :uint16, :word
+FFI.typedef :uint32, :dword
+FFI.typedef :uintptr_t, :handle
+FFI.typedef :buffer_inout, :lpwstr
+FFI.typedef :pointer, :lpcvoid
+FFI.typedef :pointer, :lpvoid
+FFI.typedef :pointer, :lpdword
+FFI.typedef :pointer, :pdword
+FFI.typedef :pointer, :phandle
+FFI.typedef :pointer, :pbool
+FFI.typedef :pointer, :ulong_ptr
+FFI.typedef :uint32, :win32_ulong
+FFI.typedef :int32, :win32_long
+FFI.typedef :int32, :win32_bool
+FFI.typedef :uint16, :wchar
+FFI.typedef :uintptr_t, :hwnd
+
+ERROR_MORE_DATA = 234
+MAX_PATH = 32_767
+
+module FFI
+  WIN32FALSE = 0
+  END_OF_WCHAR_STRING = (+"\0\0").force_encoding(Encoding::UTF_16LE).freeze
+
+  class Pointer
+    def read_wide_string_with_length(char_length)
+      # char_length is number of wide chars (typically excluding NULLs), *not* bytes
+      str = get_bytes(0, char_length * 2).force_encoding(Encoding::UTF_16LE)
+      str.encode(Encoding::UTF_8, str.encoding)
+    end
+
+    def read_wide_string_without_length(replace_invalid_chars: false)
+      wide_character = get_bytes(0, 2)
+      wide_character.force_encoding(Encoding::UTF_16LE)
+      i = 2
+      str = []
+
+      while wide_character != END_OF_WCHAR_STRING
+        str << wide_character
+        wide_character = get_bytes(i, 2)
+        wide_character.force_encoding(Encoding::UTF_16LE)
+        i += 2
+      end
+
+      if replace_invalid_chars
+        str.join.force_encoding(Encoding::UTF_16LE).encode(Encoding::UTF_8, Encoding::UTF_16LE, invalid: :replace)
+      else
+        str.join.force_encoding(Encoding::UTF_16LE).encode(Encoding::UTF_8)
+      end
+    end
+
+    def read_win32_bool
+      # BOOL is always a 32-bit integer in Win32
+      # some Win32 APIs return 1 for true, while others are non-0
+      read_int32 != WIN32FALSE
+    end
+  end
+
+  class Struct
+    def self.read_list(first_address)
+      instance = new(first_address)
+      while instance.to_ptr != Pointer::NULL
+        yield(instance)
+        instance = new(instance[:Next])
+      end
+    end
+  end
+end

data/lib/facter/resolvers/windows/ffi/hardware_ffi.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../../../facter/resolvers/windows/ffi/ffi'
+require_relative '../../../../facter/resolvers/windows/ffi/system_info'
+
+module HardwareFFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :kernel32
+  attach_function :GetNativeSystemInfo, [:pointer], :void
+
+  PROCESSOR_ARCHITECTURE_INTEL = 0
+  PROCESSOR_ARCHITECTURE_ARM = 5
+  PROCESSOR_ARCHITECTURE_IA64 = 6
+  PROCESSOR_ARCHITECTURE_AMD64 = 9
+end

data/lib/facter/resolvers/windows/ffi/identity_ffi.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../../../../facter/resolvers/windows/ffi/ffi'
+
+module IdentityFFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :secur32
+  attach_function :GetUserNameExW, %i[uint32 lpwstr pointer], :win32_bool
+
+  ffi_convention :stdcall
+  ffi_lib :shell32
+  attach_function :IsUserAnAdmin, [], :win32_bool
+
+  def self.privileged?
+    result = self.IsUserAnAdmin()
+    result && result != FFI::WIN32FALSE
+  end
+end

data/lib/facter/resolvers/windows/ffi/ip_adapter_addresses_lh.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+MAX_ADAPTER_ADDRESS_LENGTH = 8
+MAX_DHCPV6_DUID_LENGTH = 130
+
+class SockAddr < FFI::Struct
+  layout(
+    :sa_family, :ushort,
+    :sa_data, [:uint8, 14]
+  )
+end
+
+class SocketAddress < FFI::Struct
+  layout(
+    :lpSockaddr, :pointer,
+    :iSockaddrLength, :int32
+  )
+end
+
+module Enums
+  extend FFI::Library
+
+  IP_PREFIX_ORIGIN = enum(
+    :IpPrefixOriginOther, 0,
+    :IpPrefixOriginManual,
+    :IpPrefixOriginWellKnown,
+    :IpPrefixOriginDhcp,
+    :IpPrefixOriginRouterAdvertisement,
+    :IpPrefixOriginUnchanged
+  )
+
+  IP_SUFFIX_ORIGIN = enum(
+    :NlsoOther, 0,
+    :NlsoManual,
+    :NlsoWellKnown,
+    :NlsoDhcp,
+    :NlsoLinkLayerAddress,
+    :NlsoRandom,
+    :IpSuffixOriginOther,
+    :IpSuffixOriginManual,
+    :IpSuffixOriginWellKnown,
+    :IpSuffixOriginDhcp,
+    :IpSuffixOriginLinkLayerAddress,
+    :IpSuffixOriginRandom,
+    :IpSuffixOriginUnchanged
+  )
+
+  IP_DAD_STATE = enum(
+    :NldsInvalid, 0,
+    :NldsTentative,
+    :NldsDuplicate,
+    :NldsDeprecated,
+    :NldsPreferred,
+    :IpDadStateInvalid,
+    :IpDadStateTentative,
+    :IpDadStateDuplicate,
+    :IpDadStateDeprecated,
+    :IpDadStatePreferred
+  )
+
+  IF_CONNECTION_TYPE = enum(
+    :NET_IF_CONNECTION_DEDICATED, 1,
+    :NET_IF_CONNECTION_PASSIVE,
+    :NET_IF_CONNECTION_DEMAND,
+    :NET_IF_CONNECTION_MAXIMUM
+  )
+
+  TUNNEL_TYPE = enum(
+    :TUNNEL_TYPE_NONE, 0,
+    :TUNNEL_TYPE_OTHER,
+    :TUNNEL_TYPE_DIRECT,
+    :TUNNEL_TYPE_6TO4,
+    :TUNNEL_TYPE_ISATAP,
+    :TUNNEL_TYPE_TEREDO,
+    :TUNNEL_TYPE_IPHTTPS
+  )
+end
+
+class IpAdapterUnicastAddressXPUnionStruct < FFI::Struct
+  layout(
+    :Length, :win32_ulong,
+    :Flags, :dword
+  )
+end
+
+class IpAdapterUnicastAddressXPUnion < FFI::Union
+  layout(
+    :Aligment, :ulong_long,
+    :Struct, IpAdapterUnicastAddressXPUnionStruct
+  )
+end
+
+class IpAdapterUnicastAddressLH < FFI::Struct
+  layout(
+    :Union, IpAdapterUnicastAddressXPUnion,
+    :Next, :pointer,
+    :Address, SocketAddress,
+    :PrefixOrigin, Enums::IP_PREFIX_ORIGIN,
+    :SuffixOrigin, Enums::IP_SUFFIX_ORIGIN,
+    :DadState, Enums::IP_DAD_STATE,
+    :ValidLifetime, :win32_ulong,
+    :PreferredLifetime, :win32_ulong,
+    :LeaseLifetime, :win32_ulong,
+    :OnLinkPrefixLength, :uint8
+  )
+end
+
+class AdapterAddressStruct < FFI::Struct
+  layout(
+    :Length, :win32_ulong,
+    :IfIndex, :dword
+  )
+end
+
+class AdapterAddressAligmentUnion < FFI::Union
+  layout(
+    :Aligment, :uint64,
+    :Struct, AdapterAddressStruct
+  )
+end
+
+class IpAdapterAddressesLh < FFI::Struct
+  layout(
+    :Union, AdapterAddressAligmentUnion,
+    :Next, :pointer,
+    :AdapterName, :pointer,
+    :FirstUnicastAddress, :pointer,
+    :FirstAnycastAddress, :pointer,
+    :FirstMulticastAddress, :pointer,
+    :FirstDnsServerAddress, :pointer,
+    :DnsSuffix, :pointer,
+    :Description, :pointer,
+    :FriendlyName, :pointer,
+    :PhysicalAddress, [:uchar, MAX_ADAPTER_ADDRESS_LENGTH],
+    :PhysicalAddressLength, :win32_ulong,
+    :Flags, :win32_ulong,
+    :Mtu, :win32_ulong,
+    :IfType, :dword,
+    :OperStatus, :uint8,
+    :Ipv6IfIndex, :dword,
+    :ZoneIndices, [:win32_ulong, 16],
+    :FirstPrefix, :pointer,
+    :TransmitLinkSpeed, :ulong_long,
+    :ReceiveLinkSpeed, :ulong_long,
+    :FirstWinsServerAddress, :pointer,
+    :FirstGatewayAddress, :pointer,
+    :Ipv4Metric, :win32_ulong,
+    :Ipv6Metric, :win32_ulong,
+    :Luid, :ulong_long,
+    :Dhcpv4Server, SocketAddress,
+    :CompartmentId, :uint32, # https://github.com/tpn/winsdk-10/blob/master/Include/10.0.14393.0/shared/ifdef.h
+    :NetworkGuid, [:uint8, 16], # https://docs.microsoft.com/en-us/windows/win32/api/guiddef/ns-guiddef-guid
+    :ConnectionType, Enums::IF_CONNECTION_TYPE,
+    :TunnelType, Enums::TUNNEL_TYPE,
+    :Dhcpv6Server, SocketAddress,
+    :Dhcpv6ClientDuid, [:uchar, MAX_DHCPV6_DUID_LENGTH],
+    :Dhcpv6ClientDuidLength, :win32_ulong,
+    :Dhcpv6Iaid, :win32_ulong,
+    :FirstDnsSuffix, :pointer
+  )
+end

data/lib/facter/resolvers/windows/ffi/kernel_ffi.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../../../../facter/resolvers/windows/ffi/ffi'
+require_relative '../../../../facter/resolvers/windows/ffi/os_version_info_ex'
+
+module KernelFFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :ntdll
+  attach_function :RtlGetVersion, [:pointer], :int32
+
+  STATUS_SUCCESS = 0
+end

data/lib/facter/resolvers/windows/ffi/memory_ffi.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../../../../facter/resolvers/windows/ffi/ffi'
+require_relative '../../../../facter/resolvers/windows/ffi/performance_information'
+
+module MemoryFFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :psapi
+  attach_function :GetPerformanceInfo, %i[pointer dword], :win32_bool
+end

data/lib/facter/resolvers/windows/ffi/network_utils.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class NetworkUtils
+  @log = Facter::Log.new(self)
+  class << self
+    def address_to_string(addr)
+      return if addr[:lpSockaddr] == FFI::Pointer::NULL
+
+      size = FFI::MemoryPointer.new(NetworkingFFI::INET6_ADDRSTRLEN + 1)
+      buffer = FFI::MemoryPointer.new(:wchar, NetworkingFFI::INET6_ADDRSTRLEN + 1)
+      error = nil
+      3.times do
+        error = NetworkingFFI::WSAAddressToStringW(addr[:lpSockaddr], addr[:iSockaddrLength],
+                                                   FFI::Pointer::NULL, buffer, size)
+        break if error.zero?
+      end
+      unless error.zero?
+        @log.debug 'address to string translation failed!'
+        return
+      end
+      extract_address(buffer)
+    end
+
+    def extract_address(addr)
+      addr.read_wide_string_without_length.split('%').first
+    end
+
+    def ignored_ip_address(addr)
+      addr.empty? || addr.start_with?('127.', '169.254.') || addr.start_with?('fe80') || addr.eql?('::1')
+    end
+
+    def find_mac_address(adapter)
+      adapter[:PhysicalAddress].first(adapter[:PhysicalAddressLength])
+                               .map { |e| format('%<mac_address>02x', mac_address: e.to_i) }.join(':').upcase
+    end
+  end
+end

data/lib/facter/resolvers/windows/ffi/networking_ffi.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../../../facter/resolvers/windows/ffi/ffi'
+require_relative '../../../../facter/resolvers/windows/ffi/network_utils'
+require_relative '../../../../facter/resolvers/windows/ffi/ip_adapter_addresses_lh'
+
+module NetworkingFFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :iphlpapi
+  attach_function :GetAdaptersAddresses, %i[uint32 uint32 pointer pointer pointer], :dword
+
+  ffi_convention :stdcall
+  ffi_lib :ws2_32
+  attach_function :WSAAddressToStringW, %i[pointer dword pointer pointer pointer], :int32
+
+  AF_UNSPEC = 0
+  GAA_FLAG_SKIP_ANYCAST = 2
+  GAA_FLAG_SKIP_MULTICAST = 4
+  GAA_FLAG_SKIP_DNS_SERVER = 8
+  BUFFER_LENGTH = 15_000
+  ERROR_SUCCES = 0
+  ERROR_BUFFER_OVERFLOW = 111
+  ERROR_NO_DATA = 232
+  IF_OPER_STATUS_UP = 1
+  IF_OPER_STATUS_DOWN = 2
+  IF_TYPE_ETHERNET_CSMACD = 6
+  IF_TYPE_IEEE80211 = 71
+  IP_ADAPTER_DHCP_ENABLED = 4
+  INET6_ADDRSTRLEN = 46
+  AF_INET = 2
+  AF_INET6 = 23
+end

data/lib/facter/resolvers/windows/ffi/os_version_info_ex.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class OsVersionInfoEx < FFI::Struct
+  layout(
+    :dwOSVersionInfoSize, :win32_ulong,
+    :dwMajorVersion, :win32_ulong,
+    :dwMinorVersion, :win32_ulong,
+    :dwBuildNumber, :win32_ulong,
+    :dwPlatformId, :win32_ulong,
+    :szCSDVersion, [:wchar, 128],
+    :wServicePackMajor, :ushort,
+    :wServicePackMinor, :ushort,
+    :wSuiteMask, :ushort,
+    :wProductType, :uchar,
+    :wReserved, :uchar
+  )
+end

data/lib/facter/resolvers/windows/ffi/performance_information.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class PerformanceInformation < FFI::Struct
+  layout(
+    :cb, :dword,
+    :CommitTotal, :size_t,
+    :CommitLimit, :size_t,
+    :CommitPeak, :size_t,
+    :PhysicalTotal, :size_t,
+    :PhysicalAvailable, :size_t,
+    :SystemCache, :size_t,
+    :KernelTotal, :size_t,
+    :KernelPaged, :size_t,
+    :KernelNonpaged, :size_t,
+    :PageSize, :size_t,
+    :HandleCount, :dword,
+    :ProcessCount, :dword,
+    :ThreadCount, :dword
+  )
+end

data/lib/facter/resolvers/windows/ffi/system32_ffi.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../../../../facter/resolvers/windows/ffi/ffi'
+
+module System32FFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :kernel32
+  attach_function :IsWow64Process, %i[handle pointer], :win32_bool
+
+  ffi_convention :stdcall
+  ffi_lib :kernel32
+  attach_function :GetCurrentProcess, [], :handle
+
+  CSIDL_WINDOWS = 0x0024
+  H_OK = 0
+end

data/lib/facter/resolvers/windows/ffi/system_info.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class DummyStructName < FFI::Struct
+  layout(
+    :wProcessorArchitecture, :word,
+    :wReserved, :word
+  )
+end
+
+class DummyUnionName < FFI::Union
+  layout(
+    :dwOemId, :dword,
+    :dummystructname, DummyStructName
+  )
+end
+
+class SystemInfo < FFI::Struct
+  layout(
+    :dummyunionname, DummyUnionName,
+    :dwPageSize, :dword,
+    :lpMinimumApplicationAddress, :pointer,
+    :lpMaximumApplicationAddress, :pointer,
+    :dwActiveProcessorMask, :pdword,
+    :dwNumberOfProcessors, :dword,
+    :dwProcessorType, :dword,
+    :dwAllocationGranularity, :dword,
+    :wProcessorLevel, :word,
+    :wProcessorRevision, :word
+  )
+end

data/lib/facter/resolvers/windows/ffi/winnls_ffi.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative '../../../../facter/resolvers/windows/ffi/ffi'
+
+module WinnlsFFI
+  extend FFI::Library
+
+  ffi_convention :stdcall
+  ffi_lib :kernel32
+  attach_function :GetACP, [], :uint
+end

data/lib/facter/resolvers/windows/fips.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'win32/registry'
+
+module Facter
+  module Resolvers
+    module Windows
+      class Fips < BaseResolver
+        # :fips_enabled
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_fact_from_registry(fact_name) }
+          end
+
+          def read_fact_from_registry(fact_name)
+            reg = ::Win32::Registry::HKEY_LOCAL_MACHINE
+                  .open('System\\CurrentControlSet\\Control\\Lsa\\FipsAlgorithmPolicy')
+            @fact_list[:fips_enabled] = reg['Enabled'] != 0 if reg.any? { |name, _value| name == 'Enabled' }
+            reg.close
+
+            @fact_list[:fips_enabled] ||= false
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/windows/hardware_architecture.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class HardwareArchitecture < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_hardware_information(fact_name) }
+        end
+
+        def read_hardware_information(fact_name)
+          require_relative '../../../facter/resolvers/windows/ffi/hardware_ffi'
+
+          sys_info_ptr = FFI::MemoryPointer.new(SystemInfo.size)
+          HardwareFFI::GetNativeSystemInfo(sys_info_ptr)
+          sys_info = SystemInfo.new(sys_info_ptr)
+
+          hard = determine_hardware(sys_info)
+          arch = determine_architecture(hard)
+          build_facts_list(hardware: hard, architecture: arch)
+          @fact_list[fact_name]
+        rescue LoadError => e
+          log.debug("The ffi gem has not been installed: #{e}")
+        end
+
+        def determine_hardware(sys_info)
+          union = sys_info[:dummyunionname]
+          struct = union[:dummystructname]
+          case struct[:wProcessorArchitecture]
+          when HardwareFFI::PROCESSOR_ARCHITECTURE_AMD64
+            'x86_64'
+          when HardwareFFI::PROCESSOR_ARCHITECTURE_ARM
+            'arm'
+          when HardwareFFI::PROCESSOR_ARCHITECTURE_IA64
+            'ia64'
+          when HardwareFFI::PROCESSOR_ARCHITECTURE_INTEL
+            family = sys_info[:wProcessorLevel] > 5 ? 6 : sys_info[:wProcessorLevel]
+            "i#{family}86"
+          else
+            'unknown'
+          end
+        end
+
+        def determine_architecture(hardware)
+          case hardware
+          when /i[3456]86/
+            'x86'
+          when 'x86_64'
+            'x64'
+          else
+            hardware
+          end
+        end
+
+        def build_facts_list(facts)
+          @fact_list[:hardware] = facts[:hardware]
+          @fact_list[:architecture] = facts[:architecture]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/windows/identity.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Identity < BaseResolver
+      NAME_SAM_COMPATIBLE = 2
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { retrieve_facts(fact_name) }
+        end
+
+        def find_username
+          require_relative '../../../facter/resolvers/windows/ffi/identity_ffi'
+
+          size_ptr = FFI::MemoryPointer.new(:win32_ulong, 1)
+          IdentityFFI::GetUserNameExW(NAME_SAM_COMPATIBLE, FFI::Pointer::NULL, size_ptr)
+          if FFI.errno != ERROR_MORE_DATA
+            @log.debug "failure resolving identity facts: #{FFI.errno}"
+            return
+          end
+
+          name_ptr = FFI::MemoryPointer.new(:wchar, size_ptr.read_uint32)
+          if IdentityFFI::GetUserNameExW(NAME_SAM_COMPATIBLE, name_ptr, size_ptr) == FFI::WIN32FALSE
+            @log.debug "failure resolving identity facts: #{FFI.errno}"
+            return
+          end
+
+          { user: name_ptr.read_wide_string_with_length(size_ptr.read_uint32), privileged: IdentityFFI.privileged? }
+        rescue LoadError => e
+          @log.debug("Could not find username: #{e}")
+        end
+
+        def retrieve_facts(fact_name)
+          result = find_username
+          return unless result
+
+          build_fact_list(result)
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(facts)
+          @fact_list[:user] = facts[:user]
+          @fact_list[:privileged] = facts[:privileged]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/windows/kernel.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Kernel < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_os_version_information(fact_name) }
+        end
+
+        def read_os_version_information(fact_name)
+          require_relative '../../../facter/resolvers/windows/ffi/kernel_ffi'
+
+          ver_ptr = FFI::MemoryPointer.new(OsVersionInfoEx.size)
+          ver = OsVersionInfoEx.new(ver_ptr)
+          ver[:dwOSVersionInfoSize] = OsVersionInfoEx.size
+
+          if KernelFFI::RtlGetVersion(ver_ptr) != KernelFFI::STATUS_SUCCESS
+            @log.debug 'Calling Windows RtlGetVersion failed'
+            return
+          end
+
+          result = { major: ver[:dwMajorVersion], minor: ver[:dwMinorVersion], build: ver[:dwBuildNumber] }
+          build_facts_list(result)
+
+          @fact_list[fact_name]
+        rescue LoadError => e
+          @log.debug("Could not get OS version information: #{e}")
+        end
+
+        def build_facts_list(result)
+          @fact_list[:kernelversion] = "#{result[:major]}.#{result[:minor]}.#{result[:build]}"
+          @fact_list[:kernelmajorversion] = "#{result[:major]}.#{result[:minor]}"
+          @fact_list[:kernel] = 'windows'
+        end
+      end
+    end
+  end
+end