chef 12.19.36 → 14.14.25

data/lib/chef/win32/api/file.rb

@@ -67,6 +67,7 @@ class Chef
         MAX_PATH = 260
 
         SYMBOLIC_LINK_FLAG_DIRECTORY = 0x1
+        SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE = 0x2
 
         FILE_NAME_NORMALIZED = 0x0
         FILE_NAME_OPENED = 0x8
@@ -460,22 +461,22 @@ BOOL WINAPI DeviceIoControl(
 =end
         safe_attach_function :DeviceIoControl, [:HANDLE, :DWORD, :LPVOID, :DWORD, :LPVOID, :DWORD, :LPDWORD, :pointer], :BOOL
 
-#BOOL WINAPI DeleteVolumeMountPoint(
-  #_In_ LPCTSTR lpszVolumeMountPoint
-#);
+# BOOL WINAPI DeleteVolumeMountPoint(
+  # _In_ LPCTSTR lpszVolumeMountPoint
+# );
         safe_attach_function :DeleteVolumeMountPointW, [:LPCTSTR], :BOOL
 
-#BOOL WINAPI SetVolumeMountPoint(
-  #_In_ LPCTSTR lpszVolumeMountPoint,
-  #_In_ LPCTSTR lpszVolumeName
-#);
+# BOOL WINAPI SetVolumeMountPoint(
+  # _In_ LPCTSTR lpszVolumeMountPoint,
+  # _In_ LPCTSTR lpszVolumeName
+# );
         safe_attach_function :SetVolumeMountPointW, [:LPCTSTR, :LPCTSTR], :BOOL
 
-#BOOL WINAPI GetVolumeNameForVolumeMountPoint(
-  #_In_  LPCTSTR lpszVolumeMountPoint,
-  #_Out_ LPTSTR  lpszVolumeName,
-  #_In_  DWORD   cchBufferLength
-#);
+# BOOL WINAPI GetVolumeNameForVolumeMountPoint(
+  # _In_  LPCTSTR lpszVolumeMountPoint,
+  # _Out_ LPTSTR  lpszVolumeName,
+  # _In_  DWORD   cchBufferLength
+# );
         safe_attach_function :GetVolumeNameForVolumeMountPointW, [:LPCTSTR, :LPTSTR, :DWORD], :BOOL
 
 =begin

data/lib/chef/win32/api/net.rb

@@ -43,9 +43,9 @@ class Chef
 
         USE_NOFORCE = 0
         USE_FORCE = 1
-        USE_LOTS_OF_FORCE = 2 #every windows API should support this flag
+        USE_LOTS_OF_FORCE = 2 # every windows API should support this flag
 
-        NERR_Success = 0 # rubocop:disable Style/ConstantName
+        NERR_Success = 0 # rubocop:disable Naming/ConstantName
         ERROR_MORE_DATA = 234
 
         ffi_lib "netapi32"
@@ -144,6 +144,11 @@ class Chef
           layout :lgrpi0_name, :LPWSTR
         end
 
+        class LOCALGROUP_INFO_1 < FFI::Struct
+          layout :lgrpi1_name, :LPWSTR,
+                 :lgrpi1_comment, :LPWSTR
+        end
+
         class USE_INFO_2 < FFI::Struct
           include StructHelpers
 
@@ -158,32 +163,43 @@ class Chef
             :ui2_domainname, :LMSTR
         end
 
-        #NET_API_STATUS NetLocalGroupAdd(
-        #_In_  LPCWSTR servername,
-        #_In_  DWORD   level,
-        #_In_  LPBYTE  buf,
-        #_Out_ LPDWORD parm_err
-        #);
+        # NET_API_STATUS NetLocalGroupAdd(
+        # _In_  LPCWSTR servername,
+        # _In_  DWORD   level,
+        # _In_  LPBYTE  buf,
+        # _Out_ LPDWORD parm_err
+        # );
         safe_attach_function :NetLocalGroupAdd, [
           :LPCWSTR, :DWORD, :LPBYTE, :LPDWORD
         ], :DWORD
 
-        #NET_API_STATUS NetLocalGroupDel(
-        #_In_ LPCWSTR servername,
-        #_In_ LPCWSTR groupname
-        #);
+        # NET_API_STATUS NetLocalGroupSetInfo(
+        #   _In_ LPCWSTR servername,
+        #   _In_ LPCWSTR groupname,
+        #   _In_ DWORD   level,
+        #   _In_ LPBYTE  buf,
+        #   _Out_ LPDWORD parm_err
+        # );
+        safe_attach_function :NetLocalGroupSetInfo, [
+          :LPCWSTR, :LPCWSTR, :DWORD, :LPBYTE, :LPDWORD
+        ], :DWORD
+
+        # NET_API_STATUS NetLocalGroupDel(
+        # _In_ LPCWSTR servername,
+        # _In_ LPCWSTR groupname
+        # );
         safe_attach_function :NetLocalGroupDel, [:LPCWSTR, :LPCWSTR], :DWORD
 
-        #NET_API_STATUS NetLocalGroupGetMembers(
-        #_In_    LPCWSTR    servername,
-        #_In_    LPCWSTR    localgroupname,
-        #_In_    DWORD      level,
-        #_Out_   LPBYTE     *bufptr,
-        #_In_    DWORD      prefmaxlen,
-        #_Out_   LPDWORD    entriesread,
-        #_Out_   LPDWORD    totalentries,
-        #_Inout_ PDWORD_PTR resumehandle
-        #);
+        # NET_API_STATUS NetLocalGroupGetMembers(
+        # _In_    LPCWSTR    servername,
+        # _In_    LPCWSTR    localgroupname,
+        # _In_    DWORD      level,
+        # _Out_   LPBYTE     *bufptr,
+        # _In_    DWORD      prefmaxlen,
+        # _Out_   LPDWORD    entriesread,
+        # _Out_   LPDWORD    totalentries,
+        # _Inout_ PDWORD_PTR resumehandle
+        # );
         safe_attach_function :NetLocalGroupGetMembers, [
           :LPCWSTR, :LPCWSTR, :DWORD, :LPBYTE, :DWORD,
           :LPDWORD, :LPDWORD, :PDWORD_PTR
@@ -209,102 +225,102 @@ class Chef
         # );
         safe_attach_function :NetApiBufferFree, [:LPVOID], :DWORD
 
-        #NET_API_STATUS NetUserAdd(
-        #_In_  LMSTR   servername,
-        #_In_  DWORD   level,
-        #_In_  LPBYTE  buf,
-        #_Out_ LPDWORD parm_err
-        #);
+        # NET_API_STATUS NetUserAdd(
+        # _In_  LMSTR   servername,
+        # _In_  DWORD   level,
+        # _In_  LPBYTE  buf,
+        # _Out_ LPDWORD parm_err
+        # );
         safe_attach_function :NetUserAdd, [
           :LMSTR, :DWORD, :LPBYTE, :LPDWORD
         ], :DWORD
 
-        #NET_API_STATUS NetLocalGroupAddMembers(
+        # NET_API_STATUS NetLocalGroupAddMembers(
         #  _In_ LPCWSTR servername,
         #  _In_ LPCWSTR groupname,
         #  _In_ DWORD   level,
         #  _In_ LPBYTE  buf,
         #  _In_ DWORD   totalentries
-        #);
+        # );
         safe_attach_function :NetLocalGroupAddMembers, [
           :LPCWSTR, :LPCWSTR, :DWORD, :LPBYTE, :DWORD
         ], :DWORD
 
-        #NET_API_STATUS NetLocalGroupSetMembers(
+        # NET_API_STATUS NetLocalGroupSetMembers(
         #  _In_ LPCWSTR servername,
         #  _In_ LPCWSTR groupname,
         #  _In_ DWORD   level,
         #  _In_ LPBYTE  buf,
         #  _In_ DWORD   totalentries
-        #);
+        # );
         safe_attach_function :NetLocalGroupSetMembers, [
           :LPCWSTR, :LPCWSTR, :DWORD, :LPBYTE, :DWORD
         ], :DWORD
 
-        #NET_API_STATUS NetLocalGroupDelMembers(
+        # NET_API_STATUS NetLocalGroupDelMembers(
         #  _In_ LPCWSTR servername,
         #  _In_ LPCWSTR groupname,
         #  _In_ DWORD   level,
         #  _In_ LPBYTE  buf,
         #  _In_ DWORD   totalentries
-        #);
+        # );
         safe_attach_function :NetLocalGroupDelMembers, [
           :LPCWSTR, :LPCWSTR, :DWORD, :LPBYTE, :DWORD
         ], :DWORD
 
-        #NET_API_STATUS NetUserGetInfo(
+        # NET_API_STATUS NetUserGetInfo(
         #  _In_  LPCWSTR servername,
         #  _In_  LPCWSTR username,
         #  _In_  DWORD   level,
         #  _Out_ LPBYTE  *bufptr
-        #);
+        # );
         safe_attach_function :NetUserGetInfo, [
           :LPCWSTR, :LPCWSTR, :DWORD, :LPBYTE
         ], :DWORD
 
-        #NET_API_STATUS NetApiBufferFree(
+        # NET_API_STATUS NetApiBufferFree(
         #  _In_ LPVOID Buffer
-        #);
+        # );
         safe_attach_function :NetApiBufferFree, [:LPVOID], :DWORD
 
-        #NET_API_STATUS NetUserSetInfo(
+        # NET_API_STATUS NetUserSetInfo(
         #  _In_  LPCWSTR servername,
         #  _In_  LPCWSTR username,
         #  _In_  DWORD   level,
         #  _In_  LPBYTE  buf,
         #  _Out_ LPDWORD parm_err
-        #);
+        # );
         safe_attach_function :NetUserSetInfo, [
           :LPCWSTR, :LPCWSTR, :DWORD, :LPBYTE, :LPDWORD
         ], :DWORD
 
-        #NET_API_STATUS NetUserDel(
+        # NET_API_STATUS NetUserDel(
         #  _In_ LPCWSTR servername,
         #  _In_ LPCWSTR username
-        #);
+        # );
         safe_attach_function :NetUserDel, [:LPCWSTR, :LPCWSTR], :DWORD
 
-        #NET_API_STATUS NetUseDel(
-        #_In_ LMSTR UncServerName,
-        #_In_ LMSTR UseName,
-        #_In_ DWORD ForceCond
-        #);
+        # NET_API_STATUS NetUseDel(
+        # _In_ LMSTR UncServerName,
+        # _In_ LMSTR UseName,
+        # _In_ DWORD ForceCond
+        # );
         safe_attach_function :NetUseDel, [:LMSTR, :LMSTR, :DWORD], :DWORD
 
-        #NET_API_STATUS NetUseGetInfo(
-        #_In_  LMSTR  UncServerName,
-        #_In_  LMSTR  UseName,
-        #_In_  DWORD  Level,
-        #_Out_ LPBYTE *BufPtr
-        #);
+        # NET_API_STATUS NetUseGetInfo(
+        # _In_  LMSTR  UncServerName,
+        # _In_  LMSTR  UseName,
+        # _In_  DWORD  Level,
+        # _Out_ LPBYTE *BufPtr
+        # );
         safe_attach_function :NetUseGetInfo, [:LMSTR, :LMSTR, :DWORD, :pointer], :DWORD
 
-        #NET_API_STATUS NetUseAdd(
-        #_In_  LMSTR   UncServerName,
-        #_In_  DWORD   Level,
-        #_In_  LPBYTE  Buf,
-        #_Out_ LPDWORD ParmError
-        #);
+        # NET_API_STATUS NetUseAdd(
+        # _In_  LMSTR   UncServerName,
+        # _In_  DWORD   Level,
+        # _In_  LPBYTE  Buf,
+        # _Out_ LPDWORD ParmError
+        # );
         safe_attach_function :NetUseAdd, [:LMSTR, :DWORD, :LPBYTE, :LPDWORD], :DWORD
       end
     end

data/lib/chef/win32/api/security.rb

@@ -140,6 +140,8 @@ class Chef
           FILE_READ_EA | SYNCHRONIZE
         FILE_GENERIC_WRITE         = STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE
         FILE_GENERIC_EXECUTE       = STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES | FILE_EXECUTE | SYNCHRONIZE
+        WRITE                      = FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA
+        SUBFOLDERS_AND_FILES_ONLY  = INHERIT_ONLY_ACE | CONTAINER_INHERIT_ACE | OBJECT_INHERIT_ACE
         # Access Token Rights (for OpenProcessToken)
         # Access Rights for Access-Token Objects (used in OpenProcessToken)
         TOKEN_ASSIGN_PRIMARY = 0x0001
@@ -303,6 +305,17 @@ class Chef
              :SecurityDelegation,
         ]
 
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/bb530718%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396
+        ELEVATION_TYPE = enum :ELEVATION_TYPE, [
+            :TokenElevationTypeDefault, 1,
+            :TokenElevationTypeFull,
+            :TokenElevationTypeLimited
+        ]
+
+        class TOKEN_ELEVATION_TYPE < FFI::Struct
+          layout :ElevationType, :ELEVATION_TYPE
+        end
+
         # SECURITY_DESCRIPTOR is an opaque structure whose contents can vary.  Pass the
         # pointer around and free it with LocalFree.
         # http://msdn.microsoft.com/en-us/library/windows/desktop/aa379561(v=vs.85).aspx
@@ -435,6 +448,7 @@ class Chef
         safe_attach_function :LookupPrivilegeDisplayNameW, [ :LPCWSTR, :LPCWSTR, :LPWSTR, :LPDWORD, :LPDWORD ], :BOOL
         safe_attach_function :LookupPrivilegeValueW, [ :LPCWSTR, :LPCWSTR, :PLUID ], :BOOL
         safe_attach_function :LsaAddAccountRights, [ :pointer, :pointer, :pointer, :ULONG ], :NTSTATUS
+        safe_attach_function :LsaRemoveAccountRights, [ :pointer, :pointer, :BOOL, :pointer, :ULONG ], :NTSTATUS
         safe_attach_function :LsaClose, [ :LSA_HANDLE ], :NTSTATUS
         safe_attach_function :LsaEnumerateAccountRights, [ :LSA_HANDLE, :PSID, :PLSA_UNICODE_STRING, :PULONG ], :NTSTATUS
         safe_attach_function :LsaFreeMemory, [ :PVOID ], :NTSTATUS
@@ -453,6 +467,8 @@ class Chef
         safe_attach_function :SetSecurityDescriptorSacl, [ :pointer, :BOOL, :pointer, :BOOL ], :BOOL
         safe_attach_function :GetTokenInformation, [ :HANDLE, :TOKEN_INFORMATION_CLASS, :pointer, :DWORD, :PDWORD ], :BOOL
         safe_attach_function :LogonUserW, [:LPTSTR, :LPTSTR, :LPTSTR, :DWORD, :DWORD, :PHANDLE], :BOOL
+        safe_attach_function :ImpersonateLoggedOnUser, [:HANDLE], :BOOL
+        safe_attach_function :RevertToSelf, [], :BOOL
 
       end
     end

data/lib/chef/win32/eventlog.rb

@@ -16,7 +16,7 @@
 # limitations under the License.
 #
 
-if Chef::Platform.windows? && (not Chef::Platform.windows_server_2003?)
+if Chef::Platform.windows?
   if !defined? Chef::Win32EventLogLoaded
     if defined? Windows::Constants
       [:INFINITE, :WAIT_FAILED, :FORMAT_MESSAGE_IGNORE_INSERTS, :ERROR_INSUFFICIENT_BUFFER].each do |c|
@@ -26,6 +26,6 @@ if Chef::Platform.windows? && (not Chef::Platform.windows_server_2003?)
     end
 
     require "win32/eventlog"
-    Chef::Win32EventLogLoaded = true # rubocop:disable Style/ConstantName
+    Chef::Win32EventLogLoaded = true # rubocop:disable Naming/ConstantName
   end
 end

data/lib/chef/win32/file.rb

@@ -22,6 +22,7 @@ require "chef/win32/api/file"
 require "chef/win32/api/security"
 require "chef/win32/error"
 require "chef/win32/unicode"
+require "chef/win32/version"
 
 class Chef
   module ReservedNames::Win32
@@ -60,6 +61,7 @@ class Chef
         # TODO do a check for CreateSymbolicLinkW and
         # raise NotImplemented exception on older Windows
         flags = ::File.directory?(old_name) ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0
+        flags |= SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE if Chef::ReservedNames::Win32::Version.new.win_10_creators_or_higher?
         old_name = encode_path(old_name)
         new_name = encode_path(new_name)
         unless CreateSymbolicLinkW(new_name, old_name, flags)
@@ -87,6 +89,14 @@ class Chef
         is_symlink
       end
 
+      def self.realpath(file_name)
+        if symlink?(file_name)
+          readlink(file_name)
+        else
+          file_name
+        end
+      end
+
       # Returns the path of the of the symbolic link referred to by +file+.
       #
       # Requires Windows Vista or later. On older versions of Windows it

data/lib/chef/win32/mutex.rb

@@ -55,7 +55,7 @@ class Chef
           when WAIT_ABANDONED
             # Previous owner of the mutex died before it can release the
             # mutex. Log a warning and continue.
-            Chef::Log.debug "Existing owner of the mutex exited prematurely."
+            Chef::Log.trace "Existing owner of the mutex exited prematurely."
             break
           when WAIT_OBJECT_0
             # Mutex is successfully acquired.

data/lib/chef/win32/net.rb

@@ -180,6 +180,21 @@ class Chef
         end
       end
 
+      def self.net_local_group_set_info(server_name, group_name, comment)
+        server_name = wstring(server_name)
+        group_name = wstring(group_name)
+        comment = wstring(comment)
+
+        buf = LOCALGROUP_INFO_1.new
+        buf[:lgrpi1_name] = FFI::MemoryPointer.from_string(group_name)
+        buf[:lgrpi1_comment] = FFI::MemoryPointer.from_string(comment)
+
+        rc = NetLocalGroupSetInfo(server_name, group_name, 1, buf, nil)
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
       def self.net_user_del(server_name, user_name)
         server_name = wstring(server_name)
         user_name = wstring(user_name)

data/lib/chef/win32/registry.rb

@@ -2,7 +2,7 @@
 # Author:: Prajakta Purohit (<prajakta@chef.io>)
 # Author:: Lamont Granquist (<lamont@chef.io>)
 #
-# Copyright:: Copyright 2012-2016, Chef Software Inc.
+# Copyright:: Copyright 2012-2018, Chef Software Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -40,7 +40,7 @@ class Chef
       extend Chef::Mixin::WideString
 
       attr_accessor :run_context
-      attr_accessor :architecture
+      attr_reader :architecture
 
       def initialize(run_context = nil, user_architecture = :machine)
         @run_context = run_context
@@ -56,37 +56,37 @@ class Chef
         hive, key = get_hive_and_key(key_path)
         key_exists!(key_path)
         values = hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
-          reg.map { |name, type, data| { :name => name, :type => get_name_from_type(type), :data => data } }
+          reg.map { |name, type, data| { name: name, type: get_name_from_type(type), data: data } }
         end
       end
 
       def set_value(key_path, value)
         data = value[:data]
         data = data.to_s if value[:type] == :string
-        Chef::Log.debug("Updating value #{value[:name]} in registry key #{key_path} with type #{value[:type]} and data #{data}")
+        Chef::Log.trace("Updating value #{value[:name]} in registry key #{key_path} with type #{value[:type]} and data #{data}")
         key_exists!(key_path)
         hive, key = get_hive_and_key(key_path)
         if value_exists?(key_path, value)
           if data_exists?(key_path, value)
-            Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} already had those values, not updated")
+            Chef::Log.trace("Value #{value[:name]} in registry key #{key_path} already had those values, not updated")
             return false
           else
             hive.open(key, ::Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | registry_system_architecture) do |reg|
               reg.write(value[:name], get_type_from_name(value[:type]), data)
             end
-            Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} updated")
+            Chef::Log.trace("Value #{value[:name]} in registry key #{key_path} updated")
           end
         else
           hive.open(key, ::Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | registry_system_architecture) do |reg|
             reg.write(value[:name], get_type_from_name(value[:type]), data)
           end
-          Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} created")
+          Chef::Log.trace("Value #{value[:name]} in registry key #{key_path} created")
         end
         true
       end
 
       def delete_value(key_path, value)
-        Chef::Log.debug("Deleting value #{value[:name]} from registry key #{key_path}")
+        Chef::Log.trace("Deleting value #{value[:name]} from registry key #{key_path}")
         if value_exists?(key_path, value)
           begin
             hive, key = get_hive_and_key(key_path)
@@ -95,38 +95,38 @@ class Chef
           end
           hive.open(key, ::Win32::Registry::KEY_SET_VALUE | registry_system_architecture) do |reg|
             reg.delete_value(value[:name])
-            Chef::Log.debug("Deleted value #{value[:name]} from registry key #{key_path}")
+            Chef::Log.trace("Deleted value #{value[:name]} from registry key #{key_path}")
           end
         else
-          Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} does not exist, not updated")
+          Chef::Log.trace("Value #{value[:name]} in registry key #{key_path} does not exist, not updated")
         end
         true
       end
 
       def create_key(key_path, recursive)
-        Chef::Log.debug("Creating registry key #{key_path}")
+        Chef::Log.trace("Creating registry key #{key_path}")
         if keys_missing?(key_path)
           if recursive == true
-            Chef::Log.debug("Registry key #{key_path} has missing subkeys, and recursive specified, creating them....")
+            Chef::Log.trace("Registry key #{key_path} has missing subkeys, and recursive specified, creating them....")
             create_missing(key_path)
           else
             raise Chef::Exceptions::Win32RegNoRecursive, "Registry key #{key_path} has missing subkeys, and recursive not specified"
           end
         end
         if key_exists?(key_path)
-          Chef::Log.debug("Registry key #{key_path} already exists, doing nothing")
+          Chef::Log.trace("Registry key #{key_path} already exists, doing nothing")
         else
           hive, key = get_hive_and_key(key_path)
           hive.create(key, ::Win32::Registry::KEY_WRITE | registry_system_architecture)
-          Chef::Log.debug("Registry key #{key_path} created")
+          Chef::Log.trace("Registry key #{key_path} created")
         end
         true
       end
 
       def delete_key(key_path, recursive)
-        Chef::Log.debug("Deleting registry key #{key_path}")
+        Chef::Log.trace("Deleting registry key #{key_path}")
         unless key_exists?(key_path)
-          Chef::Log.debug("Registry key #{key_path}, does not exist, not deleting")
+          Chef::Log.trace("Registry key #{key_path}, does not exist, not deleting")
           return true
         end
         if has_subkeys?(key_path) && !recursive
@@ -142,7 +142,7 @@ class Chef
         hive.open(key_parent, ::Win32::Registry::KEY_WRITE | registry_system_architecture) do |reg|
           reg.delete_key(key, recursive)
         end
-        Chef::Log.debug("Registry key #{key_path} deleted")
+        Chef::Log.trace("Registry key #{key_path} deleted")
         true
       end
 
@@ -321,13 +321,13 @@ class Chef
 
       def _type_name_map
         {
-          :binary => ::Win32::Registry::REG_BINARY,
-          :string => ::Win32::Registry::REG_SZ,
-          :multi_string => ::Win32::Registry::REG_MULTI_SZ,
-          :expand_string => ::Win32::Registry::REG_EXPAND_SZ,
-          :dword => ::Win32::Registry::REG_DWORD,
-          :dword_big_endian => ::Win32::Registry::REG_DWORD_BIG_ENDIAN,
-          :qword => ::Win32::Registry::REG_QWORD,
+          binary: ::Win32::Registry::REG_BINARY,
+          string: ::Win32::Registry::REG_SZ,
+          multi_string: ::Win32::Registry::REG_MULTI_SZ,
+          expand_string: ::Win32::Registry::REG_EXPAND_SZ,
+          dword: ::Win32::Registry::REG_DWORD,
+          dword_big_endian: ::Win32::Registry::REG_DWORD_BIG_ENDIAN,
+          qword: ::Win32::Registry::REG_QWORD,
         }
       end
 
@@ -357,7 +357,7 @@ class Chef
         missing_key_arr.each do |intermediate_key|
           existing_key_path = existing_key_path << "\\" << intermediate_key
           if !key_exists?(existing_key_path)
-            Chef::Log.debug("Recursively creating registry key #{existing_key_path}")
+            Chef::Log.trace("Recursively creating registry key #{existing_key_path}")
             hive.create(get_key(existing_key_path), ::Win32::Registry::KEY_ALL_ACCESS | registry_system_architecture)
           end
         end