openvox 7.37.1 → 8.19.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/util/windows'
 
 module Puppet::Util::Windows::SID
@@ -17,10 +19,10 @@ module Puppet::Util::Windows::SID
       #   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)
+      if domain && !domain.empty? && @account_type == :SidTypeDomain
         @domain_account = @domain
-      elsif (domain && !domain.empty?)
-        @domain_account =  "#{domain}\\#{@account}"
+      elsif domain && !domain.empty?
+        @domain_account = "#{domain}\\#{@account}"
       else
         @domain_account = account
       end
@@ -58,28 +60,28 @@ module Puppet::Util::Windows::SID
             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
 
-                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} )
+                  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
 
-                  # 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*'))
+                  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, _('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
@@ -93,9 +95,9 @@ module Puppet::Util::Windows::SID
 
     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'))
+      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, _('Byte array for lookup_account_sid must not be nil and must be at least 1 byte long')
       end
 
       begin
@@ -108,7 +110,6 @@ module Puppet::Util::Windows::SID
           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)
 
                 if Puppet::Util::Windows::SID.IsValidSid(sid_ptr) == FFI::WIN32_FALSE
@@ -116,18 +117,18 @@ module Puppet::Util::Windows::SID
                 end
 
                 success = LookupAccountSidW(system_name_ptr, sid_ptr, FFI::Pointer::NULL, name_length_ptr,
-                  FFI::Pointer::NULL, domain_length_ptr, name_use_enum_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)
+                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} )
+                                         domain_ptr, domain_length_ptr, name_use_enum_ptr) == FFI::WIN32_FALSE
+                      raise Puppet::Util::Windows::Error, _('Failed to call LookupAccountSidW with bytes: %{sid_bytes}') % { sid_bytes: sid_bytes }
                     end
 
                     return new(
@@ -135,7 +136,8 @@ module Puppet::Util::Windows::SID
                       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])
+                      SID_NAME_USE[name_use_enum_ptr.read_uint32]
+                    )
                   end
                 end
               end
@@ -150,6 +152,7 @@ module Puppet::Util::Windows::SID
     # Sanitize the given account name for lookup to avoid known issues
     def self.sanitize_account_name(account_name)
       return account_name unless account_name.start_with?('APPLICATION PACKAGE AUTHORITY\\')
+
       account_name.split('\\').last
     end
     private_class_method :sanitize_account_name
@@ -182,7 +185,7 @@ module Puppet::Util::Windows::SID
     # );
     ffi_lib :advapi32
     attach_function_private :LookupAccountNameW,
-      [:lpcwstr, :lpcwstr, :pointer, :lpdword, :lpwstr, :lpdword, :pointer], :win32_bool
+                            [: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(
@@ -196,6 +199,6 @@ module Puppet::Util::Windows::SID
     # );
     ffi_lib :advapi32
     attach_function_private :LookupAccountSidW,
-      [:lpcwstr, :pointer, :lpwstr, :lpdword, :lpwstr, :lpdword, :pointer], :win32_bool
+                            [:lpcwstr, :pointer, :lpwstr, :lpdword, :lpwstr, :lpdword, :pointer], :win32_bool
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/util/windows/monkey_patches/process'
 require_relative '../../../puppet/ffi/windows'
 
@@ -13,7 +15,7 @@ module Puppet::Util::Windows::Process
   # https://docs.microsoft.com/en-us/windows/desktop/ProcThread/process-security-and-access-rights
   PROCESS_QUERY_INFORMATION = 0x0400
   # https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#maximum-path-length-limitation
-  MAX_PATH_LENGTH = 32767
+  MAX_PATH_LENGTH = 32_767
 
   def execute(command, arguments, stdin, stdout, stderr)
     create_args = {
@@ -43,15 +45,16 @@ module Puppet::Util::Windows::Process
     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"))
+        raise Puppet::Util::Windows::Error, _("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}}
+      %x(#{ENV.fetch('COMSPEC', nil)} /c exit #{exit_status})
     end
 
     exit_status
@@ -70,8 +73,7 @@ module Puppet::Util::Windows::Process
     begin
       phandle = OpenProcess(desired_access, inherit, process_id)
       if phandle == FFI::Pointer::NULL_HANDLE
-        raise Puppet::Util::Windows::Error.new(
-          "OpenProcess(#{desired_access.to_s(8)}, #{inherit}, #{process_id})")
+        raise Puppet::Util::Windows::Error, "OpenProcess(#{desired_access.to_s(8)}, #{inherit}, #{process_id})"
       end
 
       yield phandle
@@ -90,8 +92,7 @@ module Puppet::Util::Windows::Process
       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})")
+          raise Puppet::Util::Windows::Error, "OpenProcessToken(#{handle}, #{desired_access.to_s(8)}, #{token_handle_ptr})"
         end
 
         yield token_handle = token_handle_ptr.read_handle
@@ -120,7 +121,7 @@ module Puppet::Util::Windows::Process
   module_function :with_process_token
 
   def get_process_image_name_by_pid(pid)
-    image_name = ""
+    image_name = ''.dup
 
     Puppet::Util::Windows::Security.with_privilege(Puppet::Util::Windows::Security::SE_DEBUG_NAME) do
       open_process(PROCESS_QUERY_INFORMATION, false, pid) do |phandle|
@@ -132,9 +133,8 @@ module Puppet::Util::Windows::Process
             use_win32_path_format = 0
             result = QueryFullProcessImageNameW(phandle, use_win32_path_format, exe_name_ptr, exe_name_length_ptr)
             if result == FFI::WIN32_FALSE
-              raise Puppet::Util::Windows::Error.new(
-                      "QueryFullProcessImageNameW(phandle, #{use_win32_path_format}, " +
-                      "exe_name_ptr, #{max_chars}")
+              raise Puppet::Util::Windows::Error, "QueryFullProcessImageNameW(phandle, #{use_win32_path_format}, " \
+                                                  "exe_name_ptr, #{max_chars}"
             end
             image_name = exe_name_ptr.read_wide_string(exe_name_length_ptr.read_dword)
           end
@@ -152,11 +152,10 @@ module Puppet::Util::Windows::Process
         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})")
+        raise Puppet::Util::Windows::Error, "LookupPrivilegeValue(#{system_name}, #{name}, #{luid_ptr})"
       end
 
       yield LUID.new(luid_ptr)
@@ -174,19 +173,17 @@ module Puppet::Util::Windows::Process
       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})")
+        raise Puppet::Util::Windows::Error, "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)
+                                     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})")
+          raise Puppet::Util::Windows::Error, "GetTokenInformation(#{token_handle}, #{token_information}, #{token_information_buf}, " \
+                                              "#{return_length}, #{return_length_ptr})"
         end
 
         yield token_information_buf
@@ -207,7 +204,7 @@ module Puppet::Util::Windows::Process
 
     # extract each instance of LUID_AND_ATTRIBUTES
     0.upto(privileges[:count] - 1) do |i|
-      privileges[:privileges] <<  LUID_AND_ATTRIBUTES.new(privilege_ptr[i])
+      privileges[:privileges] << LUID_AND_ATTRIBUTES.new(privilege_ptr[i])
     end
 
     privileges
@@ -283,7 +280,7 @@ module Puppet::Util::Windows::Process
       result = GetVersionExW(os_version_ptr)
 
       if result == FFI::WIN32_FALSE
-        raise Puppet::Util::Windows::Error.new(_("GetVersionEx failed"))
+        raise Puppet::Util::Windows::Error, _("GetVersionEx failed")
       end
 
       ver = os_version[:dwMajorVersion]
@@ -306,20 +303,20 @@ module Puppet::Util::Windows::Process
     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 ]
+    pairs = env_ptr.read_arbitrary_wide_string_up_to(65_534, :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) }
+    pairs.to_h
   ensure
-    if env_ptr && ! env_ptr.null?
+    if env_ptr && !env_ptr.null?
       if FreeEnvironmentStringsW(env_ptr) == FFI::WIN32_FALSE
         Puppet.debug "FreeEnvironmentStringsW memory leak"
       end
@@ -328,17 +325,17 @@ module Puppet::Util::Windows::Process
   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?
+    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 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 })
+          raise Puppet::Util::Windows::Error, _("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 })
+            raise Puppet::Util::Windows::Error, _("Failed to set environment variable: %{name}") % { name: name }
           end
         end
       end
@@ -360,5 +357,4 @@ module Puppet::Util::Windows::Process
     windows_major_version >= 6
   end
   module_function :supports_elevated_security?
-
 end

data/lib/puppet/util/windows/registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/util/windows'
 
 module Puppet::Util::Windows
@@ -19,8 +21,8 @@ module Puppet::Util::Windows
 
     def root(name)
       Win32::Registry.const_get(name)
-    rescue NameError
-      raise Puppet::Error, _("Invalid registry key '%{name}'") % { name: name }, $!.backtrace
+    rescue NameError => e
+      raise Puppet::Error, _("Invalid registry key '%{name}'") % { name: name }, e.backtrace
     end
 
     def open(name, path, mode = KEY_READ | KEY64, &block)
@@ -50,7 +52,7 @@ module Puppet::Util::Windows
 
       loop do
         subkey, filetime = reg_enum_key(key, index, subkey_max_len)
-        yield subkey, filetime if !subkey.nil?
+        yield subkey, filetime unless subkey.nil?
         index += 1
         break if subkey.nil?
       end
@@ -64,7 +66,7 @@ module Puppet::Util::Windows
 
     def values(key)
       vals = {}
-      each_value(key) { |subkey, type, data| vals[subkey] = data }
+      each_value(key) { |subkey, _type, data| vals[subkey] = data }
       vals
     end
 
@@ -79,12 +81,10 @@ module Puppet::Util::Windows
       vals = {}
       names.each do |name|
         FFI::Pointer.from_string_to_wide_string(name) do |subkeyname_ptr|
-          begin
-            _, vals[name] = read(key, subkeyname_ptr)
-          rescue Puppet::Util::Windows::Error => e
-            # ignore missing names, but raise other errors
-            raise e unless e.code == Puppet::Util::Windows::Error::ERROR_FILE_NOT_FOUND
-          end
+          _, vals[name] = read(key, subkeyname_ptr)
+        rescue Puppet::Util::Windows::Error => e
+          # ignore missing names, but raise other errors
+          raise e unless e.code == Puppet::Util::Windows::Error::ERROR_FILE_NOT_FOUND
         end
       end
       vals
@@ -98,7 +98,7 @@ module Puppet::Util::Windows
 
       loop do
         subkey, type, data = reg_enum_value(key, index, value_max_len)
-        yield subkey, type, data if !subkey.nil?
+        yield subkey, type, data unless subkey.nil?
         index += 1
         break if subkey.nil?
       end
@@ -116,7 +116,8 @@ module Puppet::Util::Windows
     MAX_KEY_CHAR_LENGTH = 255 + 1
 
     def reg_enum_key(key, index, max_key_char_length = MAX_KEY_CHAR_LENGTH)
-      subkey, filetime = nil, nil
+      subkey = nil
+      filetime = nil
 
       FFI::MemoryPointer.new(:dword) do |subkey_length_ptr|
         FFI::MemoryPointer.new(FFI::WIN32::FILETIME.size) do |filetime_ptr|
@@ -125,9 +126,9 @@ module Puppet::Util::Windows
 
             # RegEnumKeyEx cannot be called twice to properly size the buffer
             result = RegEnumKeyExW(key.hkey, index,
-              subkey_ptr, subkey_length_ptr,
-              FFI::Pointer::NULL, FFI::Pointer::NULL,
-              FFI::Pointer::NULL, filetime_ptr)
+                                   subkey_ptr, subkey_length_ptr,
+                                   FFI::Pointer::NULL, FFI::Pointer::NULL,
+                                   FFI::Pointer::NULL, filetime_ptr)
 
             break if result == ERROR_NO_MORE_ITEMS
 
@@ -147,10 +148,12 @@ module Puppet::Util::Windows
     end
 
     # max number of wide characters including NULL terminator
-    MAX_VALUE_CHAR_LENGTH = 16383 + 1
+    MAX_VALUE_CHAR_LENGTH = 16_383 + 1
 
     def reg_enum_value(key, index, max_value_length = MAX_VALUE_CHAR_LENGTH)
-      subkey, type, data = nil, nil, nil
+      subkey = nil
+      type = nil
+      data = nil
 
       FFI::MemoryPointer.new(:dword) do |subkey_length_ptr|
         FFI::MemoryPointer.new(:wchar, max_value_length) do |subkey_ptr|
@@ -158,10 +161,9 @@ module Puppet::Util::Windows
           subkey_length_ptr.write_dword(max_value_length)
 
           result = RegEnumValueW(key.hkey, index,
-            subkey_ptr, subkey_length_ptr,
-            FFI::Pointer::NULL, FFI::Pointer::NULL,
-            FFI::Pointer::NULL, FFI::Pointer::NULL
-          )
+                                 subkey_ptr, subkey_length_ptr,
+                                 FFI::Pointer::NULL, FFI::Pointer::NULL,
+                                 FFI::Pointer::NULL, FFI::Pointer::NULL)
 
           break if result == ERROR_NO_MORE_ITEMS
 
@@ -185,15 +187,13 @@ module Puppet::Util::Windows
 
       FFI::MemoryPointer.new(:dword) do |max_subkey_name_length_ptr|
         FFI::MemoryPointer.new(:dword) do |max_value_name_length_ptr|
-
           status = RegQueryInfoKeyW(key.hkey,
-            FFI::MemoryPointer::NULL, FFI::MemoryPointer::NULL,
-            FFI::MemoryPointer::NULL, FFI::MemoryPointer::NULL,
-            max_subkey_name_length_ptr, FFI::MemoryPointer::NULL,
-            FFI::MemoryPointer::NULL, max_value_name_length_ptr,
-            FFI::MemoryPointer::NULL, FFI::MemoryPointer::NULL,
-            FFI::MemoryPointer::NULL
-          )
+                                    FFI::MemoryPointer::NULL, FFI::MemoryPointer::NULL,
+                                    FFI::MemoryPointer::NULL, FFI::MemoryPointer::NULL,
+                                    max_subkey_name_length_ptr, FFI::MemoryPointer::NULL,
+                                    FFI::MemoryPointer::NULL, max_value_name_length_ptr,
+                                    FFI::MemoryPointer::NULL, FFI::MemoryPointer::NULL,
+                                    FFI::MemoryPointer::NULL)
 
           if status != FFI::ERROR_SUCCESS
             msg = _("Failed to query registry %{key} for sizes") % { key: key.keyname }
@@ -203,7 +203,7 @@ module Puppet::Util::Windows
           result = [
             # Unicode characters *not* including trailing NULL
             max_subkey_name_length_ptr.read_dword + 1,
-            max_value_name_length_ptr.read_dword + 1,
+            max_value_name_length_ptr.read_dword + 1
           ]
         end
       end
@@ -240,24 +240,25 @@ module Puppet::Util::Windows
         string_length = (byte_length / WCHAR_SIZE) - 1 if byte_length > 0
 
         begin
-          case type
-            when Win32::Registry::REG_SZ, Win32::Registry::REG_EXPAND_SZ
-              result = [ type, data_ptr.read_wide_string(string_length, Encoding::UTF_8, true) ]
-            when Win32::Registry::REG_MULTI_SZ
-              result = [ type, data_ptr.read_wide_string(string_length).split(/\0/) ]
-            when Win32::Registry::REG_BINARY
-              result = [ type, data_ptr.read_bytes(byte_length) ]
-            when Win32::Registry::REG_DWORD
-              result = [ type, data_ptr.read_dword ]
-            when Win32::Registry::REG_DWORD_BIG_ENDIAN
-              result = [ type, data_ptr.order(:big).read_dword ]
-            when Win32::Registry::REG_QWORD
-              result = [ type, data_ptr.read_qword ]
-            else
-              raise TypeError, _("Type %{type} is not supported.") % { type: type }
-          end
+          result = case type
+                   when Win32::Registry::REG_SZ, Win32::Registry::REG_EXPAND_SZ
+                     [type, data_ptr.read_wide_string(string_length, Encoding::UTF_8, true)]
+                   when Win32::Registry::REG_MULTI_SZ
+                     [type, data_ptr.read_wide_string(string_length).split(/\0/)]
+                   when Win32::Registry::REG_BINARY
+                     [type, data_ptr.read_bytes(byte_length)]
+                   when Win32::Registry::REG_DWORD
+                     [type, data_ptr.read_dword]
+                   when Win32::Registry::REG_DWORD_BIG_ENDIAN
+                     [type, data_ptr.order(:big).read_dword]
+                   when Win32::Registry::REG_QWORD
+                     [type, data_ptr.read_qword]
+                   else
+                     raise TypeError, _("Type %{type} is not supported.") % { type: type }
+                   end
         rescue IndexError => ex
-          raise if (ex.message !~ /^Memory access .* is out of bounds$/i)
+          raise if ex.message !~ /^Memory access .* is out of bounds$/i
+
           parent_key_name = key.parent ? "#{key.parent.keyname}\\" : ""
           Puppet.warning _("A value in the registry key %{parent_key_name}%{key} is corrupt or invalid") % { parent_key_name: parent_key_name, key: key.keyname }
         end
@@ -270,8 +271,8 @@ module Puppet::Util::Windows
       FFI::MemoryPointer.new(:dword) do |type_ptr|
         FFI::MemoryPointer.new(:dword) do |length_ptr|
           result = RegQueryValueExW(key.hkey, name_ptr,
-            FFI::Pointer::NULL, type_ptr,
-            FFI::Pointer::NULL, length_ptr)
+                                    FFI::Pointer::NULL, type_ptr,
+                                    FFI::Pointer::NULL, length_ptr)
 
           # The call to RegQueryValueExW below is potentially unsafe:
           # https://learn.microsoft.com/en-us/windows/win32/api/winreg/nf-winreg-regqueryvalueexw
@@ -299,8 +300,8 @@ module Puppet::Util::Windows
 
           FFI::MemoryPointer.new(:byte, base_bytes_len + pad_bytes_len) do |buffer_ptr|
             result = RegQueryValueExW(key.hkey, name_ptr,
-              FFI::Pointer::NULL, type_ptr,
-              buffer_ptr, length_ptr)
+                                      FFI::Pointer::NULL, type_ptr,
+                                      buffer_ptr, length_ptr)
 
             # Ensure buffer is null terminated with 1 or 2 wchar nulls, depending on the type
             if result == FFI::ERROR_SUCCESS
@@ -370,7 +371,7 @@ module Puppet::Util::Windows
     # );
     ffi_lib :advapi32
     attach_function_private :RegEnumKeyExW,
-      [:handle, :dword, :lpwstr, :lpdword, :lpdword, :lpwstr, :lpdword, :pointer], :win32_long
+                            [:handle, :dword, :lpwstr, :lpdword, :lpdword, :lpwstr, :lpdword, :pointer], :win32_long
 
     # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724865(v=vs.85).aspx
     # LONG WINAPI RegEnumValue(
@@ -385,7 +386,7 @@ module Puppet::Util::Windows
     # );
     ffi_lib :advapi32
     attach_function_private :RegEnumValueW,
-      [:handle, :dword, :lpwstr, :lpdword, :lpdword, :lpdword, :lpbyte, :lpdword], :win32_long
+                            [:handle, :dword, :lpwstr, :lpdword, :lpdword, :lpdword, :lpbyte, :lpdword], :win32_long
 
     # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724911(v=vs.85).aspx
     # LONG WINAPI RegQueryValueExW(
@@ -398,7 +399,7 @@ module Puppet::Util::Windows
     # );
     ffi_lib :advapi32
     attach_function_private :RegQueryValueExW,
-      [:handle, :lpcwstr, :lpdword, :lpdword, :lpbyte, :lpdword], :win32_long
+                            [:handle, :lpcwstr, :lpdword, :lpdword, :lpbyte, :lpdword], :win32_long
 
     # LONG WINAPI RegDeleteValue(
     #   _In_      HKEY hKey,
@@ -406,7 +407,7 @@ module Puppet::Util::Windows
     # );
     ffi_lib :advapi32
     attach_function_private :RegDeleteValueW,
-      [:handle, :lpcwstr], :win32_long
+                            [:handle, :lpcwstr], :win32_long
 
     # LONG WINAPI RegDeleteKeyEx(
     #   _In_        HKEY hKey,
@@ -416,7 +417,7 @@ module Puppet::Util::Windows
     # );
     ffi_lib :advapi32
     attach_function_private :RegDeleteKeyExW,
-      [:handle, :lpcwstr, :win32_ulong, :dword], :win32_long
+                            [:handle, :lpcwstr, :win32_ulong, :dword], :win32_long
 
     # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724902(v=vs.85).aspx
     # LONG WINAPI RegQueryInfoKey(
@@ -435,7 +436,8 @@ module Puppet::Util::Windows
     # );
     ffi_lib :advapi32
     attach_function_private :RegQueryInfoKeyW,
-      [:handle, :lpwstr, :lpdword, :lpdword, :lpdword, :lpdword, :lpdword,
-        :lpdword, :lpdword, :lpdword, :lpdword, :pointer], :win32_long
+                            [:handle, :lpwstr, :lpdword, :lpdword, :lpdword,
+                             :lpdword, :lpdword, :lpdword, :lpdword, :lpdword,
+                             :lpdword, :pointer], :win32_long
   end
 end

data/lib/puppet/util/windows/root_certs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/util/windows'
 require_relative '../../../puppet/ssl/openssl_loader'
 require 'ffi'
@@ -17,13 +19,13 @@ class Puppet::Util::Windows::RootCerts
   # @yieldparam cert [OpenSSL::X509::Certificate] each root certificate
   # @api public
   def each
-    @roots.each {|cert| yield cert}
+    @roots.each { |cert| yield cert }
   end
 
   # Returns a new instance.
   # @return [Puppet::Util::Windows::RootCerts] object constructed from current root certificates
   def self.instance
-    new(self.load_certs)
+    new(load_certs)
   end
 
   # Returns an array of root certificates.
@@ -38,7 +40,7 @@ class Puppet::Util::Windows::RootCerts
     ptr = FFI::Pointer::NULL
     store = CertOpenSystemStoreA(nil, "ROOT")
     begin
-      while (ptr = CertEnumCertificatesInStore(store, ptr)) and not ptr.null?
+      while (ptr = CertEnumCertificatesInStore(store, ptr)) and !ptr.null?
         context = CERT_CONTEXT.new(ptr)
         cert_buf = context[:pbCertEncoded].read_bytes(context[:cbCertEncoded])
         begin