bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/util/windows/principal.rb

@@ -1,192 +0,0 @@
-require 'puppet/util/windows'
-
-module Puppet::Util::Windows::SID
-  class Principal
-    extend FFI::Library
-    attr_reader :account, :sid_bytes, :sid, :domain, :domain_account, :account_type
-
-    def initialize(account, sid_bytes, sid, domain, account_type)
-      # This is only ever called from lookup_account_sid which has already
-      # removed the potential for passing in an account like host\user
-      @account = account
-      @sid_bytes = sid_bytes
-      @sid = sid
-      @domain = domain
-      @account_type = account_type
-      # When domain is available and it is a Domain principal, use domain only
-      #   otherwise if domain is available then combine it with parsed account
-      #   otherwise when the domain is not available, use the account value directly
-      # WinNT naming standard https://msdn.microsoft.com/en-us/library/windows/desktop/aa746534(v=vs.85).aspx
-      if (domain && !domain.empty? && @account_type == :SidTypeDomain)
-        @domain_account = @domain
-      elsif (domain && !domain.empty?)
-        @domain_account =  "#{domain}\\#{@account}"
-      else
-        @domain_account = account
-      end
-    end
-
-    # added for backward compatibility
-    def ==(compare)
-      compare.is_a?(Puppet::Util::Windows::SID::Principal) &&
-        @sid_bytes == compare.sid_bytes
-    end
-
-    # returns authority qualified account name
-    # prefer to compare Principal instances with == operator or by #sid
-    def to_s
-      @domain_account
-    end
-
-    # = 8 + max sub identifiers (15) * 4
-    MAXIMUM_SID_BYTE_LENGTH = 68
-
-    ERROR_INSUFFICIENT_BUFFER = 122
-
-    def self.lookup_account_name(system_name = nil, account_name)
-      system_name_ptr = FFI::Pointer::NULL
-      begin
-        if system_name
-          system_name_wide = Puppet::Util::Windows::String.wide_string(system_name)
-          # uchar here is synonymous with byte
-          system_name_ptr = FFI::MemoryPointer.new(:byte, system_name_wide.bytesize)
-          system_name_ptr.put_array_of_uchar(0, system_name_wide.bytes.to_a)
-        end
-
-        FFI::MemoryPointer.from_string_to_wide_string(account_name) do |account_name_ptr|
-          FFI::MemoryPointer.new(:byte, MAXIMUM_SID_BYTE_LENGTH) do |sid_ptr|
-            FFI::MemoryPointer.new(:dword, 1) do |sid_length_ptr|
-              FFI::MemoryPointer.new(:dword, 1) do |domain_length_ptr|
-                FFI::MemoryPointer.new(:uint32, 1) do |name_use_enum_ptr|
-
-                sid_length_ptr.write_dword(MAXIMUM_SID_BYTE_LENGTH)
-                success = LookupAccountNameW(system_name_ptr, account_name_ptr, sid_ptr, sid_length_ptr,
-                  FFI::Pointer::NULL, domain_length_ptr, name_use_enum_ptr)
-                last_error = FFI.errno
-
-                if (success == FFI::WIN32_FALSE && last_error != ERROR_INSUFFICIENT_BUFFER)
-                  raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountNameW with account: %{account_name}') % { account_name: account_name}, last_error)
-                end
-
-                FFI::MemoryPointer.new(:lpwstr, domain_length_ptr.read_dword) do |domain_ptr|
-                  if LookupAccountNameW(system_name_ptr, account_name_ptr,
-                      sid_ptr, sid_length_ptr,
-                      domain_ptr, domain_length_ptr, name_use_enum_ptr) == FFI::WIN32_FALSE
-                  raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountNameW with account: %{account_name}') % { account_name: account_name} )
-                  end
-
-                  # with a SID returned, loop back through lookup_account_sid to retrieve official name
-                  # necessary when accounts like . or '' are passed in
-                  return lookup_account_sid(
-                    system_name,
-                    sid_ptr.read_bytes(sid_length_ptr.read_dword).unpack('C*'))
-                  end
-                end
-              end
-            end
-          end
-        end
-      ensure
-        system_name_ptr.free if system_name_ptr != FFI::Pointer::NULL
-      end
-    end
-
-    def self.lookup_account_sid(system_name = nil, sid_bytes)
-      system_name_ptr = FFI::Pointer::NULL
-      if (sid_bytes.nil? || (!sid_bytes.is_a? Array) || (sid_bytes.length == 0))
-        #TRANSLATORS `lookup_account_sid` is a variable name and should not be translated
-        raise Puppet::Util::Windows::Error.new(_('Byte array for lookup_account_sid must not be nil and must be at least 1 byte long'))
-      end
-
-      begin
-        if system_name
-          system_name_wide = Puppet::Util::Windows::String.wide_string(system_name)
-          # uchar here is synonymous with byte
-          system_name_ptr = FFI::MemoryPointer.new(:byte, system_name_wide.bytesize)
-          system_name_ptr.put_array_of_uchar(0, system_name_wide.bytes.to_a)
-        end
-
-        FFI::MemoryPointer.new(:byte, sid_bytes.length) do |sid_ptr|
-          FFI::MemoryPointer.new(:dword, 1) do |name_length_ptr|
-            FFI::MemoryPointer.new(:dword, 1) do |domain_length_ptr|
-              FFI::MemoryPointer.new(:uint32, 1) do |name_use_enum_ptr|
-
-                sid_ptr.write_array_of_uchar(sid_bytes)
-                success = LookupAccountSidW(system_name_ptr, sid_ptr, FFI::Pointer::NULL, name_length_ptr,
-                  FFI::Pointer::NULL, domain_length_ptr, name_use_enum_ptr)
-                last_error = FFI.errno
-
-                if (success == FFI::WIN32_FALSE && last_error != ERROR_INSUFFICIENT_BUFFER)
-                  raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountSidW with bytes: %{sid_bytes}') % { sid_bytes: sid_bytes}, last_error)
-                end
-
-                FFI::MemoryPointer.new(:lpwstr, name_length_ptr.read_dword) do |name_ptr|
-                  FFI::MemoryPointer.new(:lpwstr, domain_length_ptr.read_dword) do |domain_ptr|
-                    if LookupAccountSidW(system_name_ptr, sid_ptr, name_ptr, name_length_ptr,
-                        domain_ptr, domain_length_ptr, name_use_enum_ptr) == FFI::WIN32_FALSE
-                     raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountSidW with bytes: %{sid_bytes}') % { sid_bytes: sid_bytes} )
-                    end
-
-                    return new(
-                      name_ptr.read_wide_string(name_length_ptr.read_dword),
-                      sid_bytes,
-                      Puppet::Util::Windows::SID.sid_ptr_to_string(sid_ptr),
-                      domain_ptr.read_wide_string(domain_length_ptr.read_dword),
-                      SID_NAME_USE[name_use_enum_ptr.read_uint32])
-                  end
-                end
-              end
-            end
-          end
-        end
-      ensure
-        system_name_ptr.free if system_name_ptr != FFI::Pointer::NULL
-      end
-    end
-
-    ffi_convention :stdcall
-
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379601(v=vs.85).aspx
-    SID_NAME_USE = enum(
-      :SidTypeUser, 1,
-      :SidTypeGroup, 2,
-      :SidTypeDomain, 3,
-      :SidTypeAlias, 4,
-      :SidTypeWellKnownGroup, 5,
-      :SidTypeDeletedAccount, 6,
-      :SidTypeInvalid, 7,
-      :SidTypeUnknown, 8,
-      :SidTypeComputer, 9,
-      :SidTypeLabel, 10
-    )
-
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379159(v=vs.85).aspx
-    # BOOL WINAPI LookupAccountName(
-    #   _In_opt_  LPCTSTR       lpSystemName,
-    #   _In_      LPCTSTR       lpAccountName,
-    #   _Out_opt_ PSID          Sid,
-    #   _Inout_   LPDWORD       cbSid,
-    #   _Out_opt_ LPTSTR        ReferencedDomainName,
-    #   _Inout_   LPDWORD       cchReferencedDomainName,
-    #   _Out_     PSID_NAME_USE peUse
-    # );
-    ffi_lib :advapi32
-    attach_function_private :LookupAccountNameW,
-      [:lpcwstr, :lpcwstr, :pointer, :lpdword, :lpwstr, :lpdword, :pointer], :win32_bool
-
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379166(v=vs.85).aspx
-    # BOOL WINAPI LookupAccountSid(
-    #   _In_opt_  LPCTSTR       lpSystemName,
-    #   _In_      PSID          lpSid,
-    #   _Out_opt_ LPTSTR        lpName,
-    #   _Inout_   LPDWORD       cchName,
-    #   _Out_opt_ LPTSTR        lpReferencedDomainName,
-    #   _Inout_   LPDWORD       cchReferencedDomainName,
-    #   _Out_     PSID_NAME_USE peUse
-    # );
-    ffi_lib :advapi32
-    attach_function_private :LookupAccountSidW,
-      [:lpcwstr, :pointer, :lpwstr, :lpdword, :lpwstr, :lpdword, :pointer], :win32_bool
-  end
-end
-

data/vendored/puppet/lib/puppet/util/windows/process.rb

@@ -1,497 +0,0 @@
-require 'puppet/util/windows'
-require 'win32/process'
-require 'ffi'
-
-module Puppet::Util::Windows::Process
-  extend Puppet::Util::Windows::String
-  extend FFI::Library
-
-  WAIT_TIMEOUT = 0x102
-
-  def execute(command, arguments, stdin, stdout, stderr)
-    Process.create( :command_line => command, :startup_info => {:stdin => stdin, :stdout => stdout, :stderr => stderr}, :close_handles => false )
-  end
-  module_function :execute
-
-  def wait_process(handle)
-    while WaitForSingleObject(handle, 0) == WAIT_TIMEOUT
-      sleep(1)
-    end
-
-    exit_status = -1
-    FFI::MemoryPointer.new(:dword, 1) do |exit_status_ptr|
-      if GetExitCodeProcess(handle, exit_status_ptr) == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new(_("Failed to get child process exit code"))
-      end
-      exit_status = exit_status_ptr.read_dword
-
-      # $CHILD_STATUS is not set when calling win32/process Process.create
-      # and since it's read-only, we can't set it. But we can execute a
-      # a shell that simply returns the desired exit status, which has the
-      # desired effect.
-      %x{#{ENV['COMSPEC']} /c exit #{exit_status}}
-    end
-
-    exit_status
-  end
-  module_function :wait_process
-
-  def get_current_process
-    # this pseudo-handle does not require closing per MSDN docs
-    GetCurrentProcess()
-  end
-  module_function :get_current_process
-
-  def open_process_token(handle, desired_access, &block)
-    token_handle = nil
-    begin
-      FFI::MemoryPointer.new(:handle, 1) do |token_handle_ptr|
-        result = OpenProcessToken(handle, desired_access, token_handle_ptr)
-        if result == FFI::WIN32_FALSE
-          raise Puppet::Util::Windows::Error.new(
-            "OpenProcessToken(#{handle}, #{desired_access.to_s(8)}, #{token_handle_ptr})")
-        end
-
-        yield token_handle = token_handle_ptr.read_handle
-      end
-
-      token_handle
-    ensure
-      FFI::WIN32.CloseHandle(token_handle) if token_handle
-    end
-
-    # token_handle has had CloseHandle called against it, so nothing to return
-    nil
-  end
-  module_function :open_process_token
-
-  # Execute a block with the current process token
-  def with_process_token(access, &block)
-    handle = get_current_process
-    open_process_token(handle, access) do |token_handle|
-      yield token_handle
-    end
-
-    # all handles have been closed, so nothing to safely return
-    nil
-  end
-  module_function :with_process_token
-
-  def lookup_privilege_value(name, system_name = '', &block)
-    FFI::MemoryPointer.new(LUID.size) do |luid_ptr|
-      result = LookupPrivilegeValueW(
-        wide_string(system_name),
-        wide_string(name.to_s),
-        luid_ptr
-        )
-
-      if result == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new(
-          "LookupPrivilegeValue(#{system_name}, #{name}, #{luid_ptr})")
-      end
-
-      yield LUID.new(luid_ptr)
-    end
-
-    # the underlying MemoryPointer for LUID is cleaned up by this point
-    nil
-  end
-  module_function :lookup_privilege_value
-
-  def get_token_information(token_handle, token_information, &block)
-    # to determine buffer size
-    FFI::MemoryPointer.new(:dword, 1) do |return_length_ptr|
-      result = GetTokenInformation(token_handle, token_information, nil, 0, return_length_ptr)
-      return_length = return_length_ptr.read_dword
-
-      if return_length <= 0
-        raise Puppet::Util::Windows::Error.new(
-          "GetTokenInformation(#{token_handle}, #{token_information}, nil, 0, #{return_length_ptr})")
-      end
-
-      # re-call API with properly sized buffer for all results
-      FFI::MemoryPointer.new(return_length) do |token_information_buf|
-        result = GetTokenInformation(token_handle, token_information,
-          token_information_buf, return_length, return_length_ptr)
-
-        if result == FFI::WIN32_FALSE
-          raise Puppet::Util::Windows::Error.new(
-            "GetTokenInformation(#{token_handle}, #{token_information}, #{token_information_buf}, " +
-              "#{return_length}, #{return_length_ptr})")
-        end
-
-        yield token_information_buf
-      end
-    end
-
-    # GetTokenInformation buffer has been cleaned up by this point, nothing to return
-    nil
-  end
-  module_function :get_token_information
-
-  def parse_token_information_as_token_privileges(token_information_buf)
-    raw_privileges = TOKEN_PRIVILEGES.new(token_information_buf)
-    privileges = { :count => raw_privileges[:PrivilegeCount], :privileges => [] }
-
-    offset = token_information_buf + TOKEN_PRIVILEGES.offset_of(:Privileges)
-    privilege_ptr = FFI::Pointer.new(LUID_AND_ATTRIBUTES, offset)
-
-    # extract each instance of LUID_AND_ATTRIBUTES
-    0.upto(privileges[:count] - 1) do |i|
-      privileges[:privileges] <<  LUID_AND_ATTRIBUTES.new(privilege_ptr[i])
-    end
-
-    privileges
-  end
-  module_function :parse_token_information_as_token_privileges
-
-  def parse_token_information_as_token_elevation(token_information_buf)
-    TOKEN_ELEVATION.new(token_information_buf)
-  end
-  module_function :parse_token_information_as_token_elevation
-
-  TOKEN_ALL_ACCESS = 0xF01FF
-  ERROR_NO_SUCH_PRIVILEGE = 1313
-  def process_privilege_symlink?
-    privilege_symlink = false
-    handle = get_current_process
-    open_process_token(handle, TOKEN_ALL_ACCESS) do |token_handle|
-      lookup_privilege_value('SeCreateSymbolicLinkPrivilege') do |luid|
-        get_token_information(token_handle, :TokenPrivileges) do |token_info|
-          token_privileges = parse_token_information_as_token_privileges(token_info)
-          privilege_symlink = token_privileges[:privileges].any? { |p| p[:Luid].values == luid.values }
-        end
-      end
-    end
-
-    privilege_symlink
-  rescue Puppet::Util::Windows::Error => e
-    if e.code == ERROR_NO_SUCH_PRIVILEGE
-      false # pre-Vista
-    else
-      raise e
-    end
-  end
-  module_function :process_privilege_symlink?
-
-  TOKEN_QUERY = 0x0008
-  # Returns whether or not the owner of the current process is running
-  # with elevated security privileges.
-  #
-  # Only supported on Windows Vista or later.
-  #
-  def elevated_security?
-    # default / pre-Vista
-    elevated = false
-    handle = nil
-
-    begin
-      handle = get_current_process
-      open_process_token(handle, TOKEN_QUERY) do |token_handle|
-        get_token_information(token_handle, :TokenElevation) do |token_info|
-          token_elevation = parse_token_information_as_token_elevation(token_info)
-          # TokenIsElevated member of the TOKEN_ELEVATION struct
-          elevated = token_elevation[:TokenIsElevated] != 0
-        end
-      end
-
-      elevated
-    rescue Puppet::Util::Windows::Error => e
-      raise e if e.code != ERROR_NO_SUCH_PRIVILEGE
-    ensure
-      FFI::WIN32.CloseHandle(handle) if handle
-    end
-  end
-  module_function :elevated_security?
-
-  def windows_major_version
-    ver = 0
-
-    FFI::MemoryPointer.new(OSVERSIONINFO.size) do |os_version_ptr|
-      os_version = OSVERSIONINFO.new(os_version_ptr)
-      os_version[:dwOSVersionInfoSize] = OSVERSIONINFO.size
-
-      result = GetVersionExW(os_version_ptr)
-
-      if result == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new(_("GetVersionEx failed"))
-      end
-
-      ver = os_version[:dwMajorVersion]
-    end
-
-    ver
-  end
-  module_function :windows_major_version
-
-  # Returns a hash of the current environment variables encoded as UTF-8
-  # The memory block returned from GetEnvironmentStringsW is double-null terminated and the vars are paired as below;
-  # Var1=Value1\0
-  # Var2=Value2\0
-  # VarX=ValueX\0\0
-  # Note - Some env variable names start with '=' and are excluded from the return value
-  # Note - The env_ptr MUST be freed using the FreeEnvironmentStringsW function
-  # Note - There is no technical limitation to the size of the environment block returned.
-  #   However a practical limit of 64K is used as no single environment variable can exceed 32KB
-  def get_environment_strings
-    env_ptr = GetEnvironmentStringsW()
-
-    # pass :invalid => :replace to the Ruby String#encode to use replacement characters
-    pairs = env_ptr.read_arbitrary_wide_string_up_to(65534, :double_null, { :invalid => :replace })
-      .split(?\x00)
-      .reject { |env_str| env_str.nil? || env_str.empty? || env_str[0] == '=' }
-      .reject do |env_str|
-        # reject any string containing the Unicode replacement character
-        if env_str.include?("\uFFFD")
-          Puppet.warning(_("Discarding environment variable %{string} which contains invalid bytes") % { string: env_str })
-          true
-        end
-      end
-      .map { |env_pair| env_pair.split('=', 2) }
-    Hash[ pairs ]
-  ensure
-    if env_ptr && ! env_ptr.null?
-      if FreeEnvironmentStringsW(env_ptr) == FFI::WIN32_FALSE
-        Puppet.debug "FreeEnvironmentStringsW memory leak"
-      end
-    end
-  end
-  module_function :get_environment_strings
-
-  def set_environment_variable(name, val)
-    raise Puppet::Util::Windows::Error(_('environment variable name must not be nil or empty')) if ! name || name.empty?
-
-    FFI::MemoryPointer.from_string_to_wide_string(name) do |name_ptr|
-      if (val.nil?)
-        if SetEnvironmentVariableW(name_ptr, FFI::MemoryPointer::NULL) == FFI::WIN32_FALSE
-          raise Puppet::Util::Windows::Error.new(_("Failed to remove environment variable: %{name}") % { name: name })
-        end
-      else
-        FFI::MemoryPointer.from_string_to_wide_string(val) do |val_ptr|
-          if SetEnvironmentVariableW(name_ptr, val_ptr) == FFI::WIN32_FALSE
-            raise Puppet::Util::Windows::Error.new(_("Failed to set environment variable: %{name}") % { name: name })
-          end
-        end
-      end
-    end
-  end
-  module_function :set_environment_variable
-
-  def get_system_default_ui_language
-    GetSystemDefaultUILanguage()
-  end
-  module_function :get_system_default_ui_language
-
-  # Returns whether or not the OS has the ability to set elevated
-  # token information.
-  #
-  # Returns true on Windows Vista or later, otherwise false
-  #
-  def supports_elevated_security?
-    windows_major_version >= 6
-  end
-  module_function :supports_elevated_security?
-
-  ABOVE_NORMAL_PRIORITY_CLASS = 0x0008000
-  BELOW_NORMAL_PRIORITY_CLASS = 0x0004000
-  HIGH_PRIORITY_CLASS         = 0x0000080
-  IDLE_PRIORITY_CLASS         = 0x0000040
-  NORMAL_PRIORITY_CLASS       = 0x0000020
-  REALTIME_PRIORITY_CLASS     = 0x0000010
-
-  ffi_convention :stdcall
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms687032(v=vs.85).aspx
-  # DWORD WINAPI WaitForSingleObject(
-  #   _In_  HANDLE hHandle,
-  #   _In_  DWORD dwMilliseconds
-  # );
-  ffi_lib :kernel32
-  attach_function_private :WaitForSingleObject,
-    [:handle, :dword], :dword
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683189(v=vs.85).aspx
-  # BOOL WINAPI GetExitCodeProcess(
-  #   _In_   HANDLE hProcess,
-  #   _Out_  LPDWORD lpExitCode
-  # );
-  ffi_lib :kernel32
-  attach_function_private :GetExitCodeProcess,
-    [:handle, :lpdword], :win32_bool
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683179(v=vs.85).aspx
-  # HANDLE WINAPI GetCurrentProcess(void);
-  ffi_lib :kernel32
-  attach_function_private :GetCurrentProcess, [], :handle
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683187(v=vs.85).aspx
-  # LPTCH GetEnvironmentStrings(void);
-  ffi_lib :kernel32
-  attach_function_private :GetEnvironmentStringsW, [], :pointer
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms683151(v=vs.85).aspx
-  # BOOL FreeEnvironmentStrings(
-  #   _In_ LPTCH lpszEnvironmentBlock
-  # );
-  ffi_lib :kernel32
-  attach_function_private :FreeEnvironmentStringsW,
-    [:pointer], :win32_bool
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms686206(v=vs.85).aspx
-  # BOOL WINAPI SetEnvironmentVariableW(
-  #     _In_     LPCTSTR lpName,
-  #     _In_opt_ LPCTSTR lpValue
-  #   );
-  ffi_lib :kernel32
-  attach_function_private :SetEnvironmentVariableW,
-    [:lpcwstr, :lpcwstr], :win32_bool
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379295(v=vs.85).aspx
-  # BOOL WINAPI OpenProcessToken(
-  #   _In_   HANDLE ProcessHandle,
-  #   _In_   DWORD DesiredAccess,
-  #   _Out_  PHANDLE TokenHandle
-  # );
-  ffi_lib :advapi32
-  attach_function_private :OpenProcessToken,
-    [:handle, :dword, :phandle], :win32_bool
-
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379261(v=vs.85).aspx
-  # typedef struct _LUID {
-  #   DWORD LowPart;
-  #   LONG  HighPart;
-  # } LUID, *PLUID;
-  class LUID < FFI::Struct
-    layout :LowPart, :dword,
-           :HighPart, :win32_long
-  end
-
-  # https://msdn.microsoft.com/en-us/library/Windows/desktop/aa379180(v=vs.85).aspx
-  # BOOL WINAPI LookupPrivilegeValue(
-  #   _In_opt_  LPCTSTR lpSystemName,
-  #   _In_      LPCTSTR lpName,
-  #   _Out_     PLUID lpLuid
-  # );
-  ffi_lib :advapi32
-  attach_function_private :LookupPrivilegeValueW,
-    [:lpcwstr, :lpcwstr, :pointer], :win32_bool
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379626(v=vs.85).aspx
-  TOKEN_INFORMATION_CLASS = enum(
-      :TokenUser, 1,
-      :TokenGroups,
-      :TokenPrivileges,
-      :TokenOwner,
-      :TokenPrimaryGroup,
-      :TokenDefaultDacl,
-      :TokenSource,
-      :TokenType,
-      :TokenImpersonationLevel,
-      :TokenStatistics,
-      :TokenRestrictedSids,
-      :TokenSessionId,
-      :TokenGroupsAndPrivileges,
-      :TokenSessionReference,
-      :TokenSandBoxInert,
-      :TokenAuditPolicy,
-      :TokenOrigin,
-      :TokenElevationType,
-      :TokenLinkedToken,
-      :TokenElevation,
-      :TokenHasRestrictions,
-      :TokenAccessInformation,
-      :TokenVirtualizationAllowed,
-      :TokenVirtualizationEnabled,
-      :TokenIntegrityLevel,
-      :TokenUIAccess,
-      :TokenMandatoryPolicy,
-      :TokenLogonSid,
-      :TokenIsAppContainer,
-      :TokenCapabilities,
-      :TokenAppContainerSid,
-      :TokenAppContainerNumber,
-      :TokenUserClaimAttributes,
-      :TokenDeviceClaimAttributes,
-      :TokenRestrictedUserClaimAttributes,
-      :TokenRestrictedDeviceClaimAttributes,
-      :TokenDeviceGroups,
-      :TokenRestrictedDeviceGroups,
-      :TokenSecurityAttributes,
-      :TokenIsRestricted,
-      :MaxTokenInfoClass
-  )
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379263(v=vs.85).aspx
-  # typedef struct _LUID_AND_ATTRIBUTES {
-  #   LUID  Luid;
-  #   DWORD Attributes;
-  # } LUID_AND_ATTRIBUTES, *PLUID_AND_ATTRIBUTES;
-  class LUID_AND_ATTRIBUTES < FFI::Struct
-    layout :Luid, LUID,
-           :Attributes, :dword
-  end
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379630(v=vs.85).aspx
-  # typedef struct _TOKEN_PRIVILEGES {
-  #   DWORD               PrivilegeCount;
-  #   LUID_AND_ATTRIBUTES Privileges[ANYSIZE_ARRAY];
-  # } TOKEN_PRIVILEGES, *PTOKEN_PRIVILEGES;
-  class TOKEN_PRIVILEGES < FFI::Struct
-    layout :PrivilegeCount, :dword,
-           :Privileges, [LUID_AND_ATTRIBUTES, 1]    # placeholder for offset
-  end
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/bb530717(v=vs.85).aspx
-  # typedef struct _TOKEN_ELEVATION {
-  #   DWORD TokenIsElevated;
-  # } TOKEN_ELEVATION, *PTOKEN_ELEVATION;
-  class TOKEN_ELEVATION < FFI::Struct
-    layout :TokenIsElevated, :dword
-  end
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa446671(v=vs.85).aspx
-  # BOOL WINAPI GetTokenInformation(
-  #   _In_       HANDLE TokenHandle,
-  #   _In_       TOKEN_INFORMATION_CLASS TokenInformationClass,
-  #   _Out_opt_  LPVOID TokenInformation,
-  #   _In_       DWORD TokenInformationLength,
-  #   _Out_      PDWORD ReturnLength
-  # );
-  ffi_lib :advapi32
-  attach_function_private :GetTokenInformation,
-    [:handle, TOKEN_INFORMATION_CLASS, :lpvoid, :dword, :pdword ], :win32_bool
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724834%28v=vs.85%29.aspx
-  # typedef struct _OSVERSIONINFO {
-  #   DWORD dwOSVersionInfoSize;
-  #   DWORD dwMajorVersion;
-  #   DWORD dwMinorVersion;
-  #   DWORD dwBuildNumber;
-  #   DWORD dwPlatformId;
-  #   TCHAR szCSDVersion[128];
-  # } OSVERSIONINFO;
-  class OSVERSIONINFO < FFI::Struct
-    layout(
-      :dwOSVersionInfoSize, :dword,
-      :dwMajorVersion, :dword,
-      :dwMinorVersion, :dword,
-      :dwBuildNumber, :dword,
-      :dwPlatformId, :dword,
-      :szCSDVersion, [:wchar, 128]
-    )
-  end
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724451(v=vs.85).aspx
-  # BOOL WINAPI GetVersionEx(
-  #   _Inout_  LPOSVERSIONINFO lpVersionInfo
-  # );
-  ffi_lib :kernel32
-  attach_function_private :GetVersionExW,
-    [:pointer], :win32_bool
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/dd318123(v=vs.85).aspx
-  # LANGID GetSystemDefaultUILanguage(void);
-  ffi_lib :kernel32
-  attach_function_private :GetSystemDefaultUILanguage, [], :word
-end