rubyntlm 0.6.6 → 0.6.7

data/lib/net/ntlm/message/type2.rb

@@ -1,18 +1,18 @@
+# frozen_string_literal: true
+
 module Net
   module NTLM
     class Message
-
       # @private false
       class Type2 < Message
-
-        string          :sign,        { :size => 8, :value => SSP_SIGN }
-        int32LE         :type,        { :value => 2 }
-        security_buffer :target_name, { :size => 0, :value => "" }
-        int32LE         :flag,        { :value => DEFAULT_FLAGS[:TYPE2] }
-        int64LE         :challenge,   { :value => 0}
-        int64LE         :context,     { :value => 0, :active => false }
-        security_buffer :target_info, { :value => "", :active => false }
-        string          :os_version,  { :size => 8, :value => "", :active => false }
+        string :sign, { size: 8, value: SSP_SIGN }
+        int32_le :type, { value: 2 }
+        security_buffer :target_name, { size: 0, value: '' }
+        int32_le         :flag,        { value: DEFAULT_FLAGS[:TYPE2] }
+        int64_le         :challenge,   { value: 0 }
+        int64_le         :context,     { value: 0, active: false }
+        security_buffer :target_info, { value: '', active: false }
+        string          :os_version,  { size: 8, value: '', active: false }
 
         # Generates a Type 3 response based on the Type 2 Information
         # @return [Type3]
@@ -24,79 +24,99 @@ module Net
         # @note An empty :domain option authenticates to the local machine.
         # @note The :use_default_target has precedence over the :domain option
         def response(arg, opt = {})
+          creds = response_credentials(arg, opt)
+          normalize_response_encoding(creds, opt)
+          creds[:domain] = target_name if opt[:use_default_target]
+          lm_res, ntlm_res = build_responses(creds, opt)
+          build_type3(creds, lm_res, ntlm_res)
+        end
+
+        private
+
+        def response_credentials(arg, opt)
           usr = arg[:user]
           pwd = arg[:password]
-          domain = arg[:domain] ? arg[:domain].upcase : ""
-          if usr.nil? or pwd.nil?
-            raise ArgumentError, "user and password have to be supplied"
-          end
+          raise ArgumentError, 'user and password have to be supplied' if usr.nil? || pwd.nil?
 
-          if opt[:workstation]
-            ws = opt[:workstation]
-          else
-            ws = Socket.gethostname
-          end
-
-          if opt[:client_challenge]
-            cc  = opt[:client_challenge]
-          else
-            cc = rand(MAX64)
-          end
-          cc = NTLM::pack_int64le(cc) if cc.is_a?(Integer)
-          opt[:client_challenge] = cc
+          build_credentials(usr, pwd, arg, opt)
+        end
 
-          if has_flag?(:OEM) and opt[:unicode]
-            usr = NTLM::EncodeUtil.decode_utf16le(usr)
-            pwd = NTLM::EncodeUtil.decode_utf16le(pwd)
-            ws  = NTLM::EncodeUtil.decode_utf16le(ws)
-            domain = NTLM::EncodeUtil.decode_utf16le(domain)
-            opt[:unicode] = false
-          end
+        def build_credentials(usr, pwd, arg, opt)
+          {
+            user: usr,
+            password: pwd,
+            domain: arg[:domain] ? arg[:domain].upcase : '',
+            workstation: opt[:workstation] || Socket.gethostname,
+            client_challenge: normalize_client_challenge(opt)
+          }
+        end
 
-          if has_flag?(:UNICODE) and !opt[:unicode]
-            usr = NTLM::EncodeUtil.encode_utf16le(usr)
-            pwd = NTLM::EncodeUtil.encode_utf16le(pwd)
-            ws  = NTLM::EncodeUtil.encode_utf16le(ws)
-            domain = NTLM::EncodeUtil.encode_utf16le(domain)
-            opt[:unicode] = true
-          end
+        def normalize_client_challenge(opt)
+          cc = opt[:client_challenge] || rand(MAX64)
+          cc = NTLM.pack_int64le(cc) if cc.is_a?(Integer)
+          opt[:client_challenge] = cc
+        end
 
-          if opt[:use_default_target]
-            domain = self.target_name
-          end
+        def normalize_response_encoding(creds, opt)
+          decode_response_strings(creds, opt) if flag?(:OEM) && opt[:unicode]
+          encode_response_strings(creds, opt) if flag?(:UNICODE) && !opt[:unicode]
+        end
 
-          ti = self.target_info
+        def decode_response_strings(creds, opt)
+          creds[:user] = NTLM::EncodeUtil.decode_utf16le(creds[:user])
+          creds[:password] = NTLM::EncodeUtil.decode_utf16le(creds[:password])
+          creds[:workstation] = NTLM::EncodeUtil.decode_utf16le(creds[:workstation])
+          creds[:domain] = NTLM::EncodeUtil.decode_utf16le(creds[:domain])
+          opt[:unicode] = false
+        end
 
-          chal = self[:challenge].serialize
+        def encode_response_strings(creds, opt)
+          creds[:user] = NTLM::EncodeUtil.encode_utf16le(creds[:user])
+          creds[:password] = NTLM::EncodeUtil.encode_utf16le(creds[:password])
+          creds[:workstation] = NTLM::EncodeUtil.encode_utf16le(creds[:workstation])
+          creds[:domain] = NTLM::EncodeUtil.encode_utf16le(creds[:domain])
+          opt[:unicode] = true
+        end
 
+        def build_responses(creds, opt)
+          challenge = self[:challenge].serialize
           if opt[:ntlmv2]
-            ar = {:ntlmv2_hash => NTLM::ntlmv2_hash(usr, pwd, domain, opt), :challenge => chal, :target_info => ti}
-            lm_res = NTLM::lmv2_response(ar, opt)
-            ntlm_res = NTLM::ntlmv2_response(ar, opt)
-          elsif has_flag?(:NTLM2_KEY)
-            ar = {:ntlm_hash => NTLM::ntlm_hash(pwd, opt), :challenge => chal}
-            lm_res, ntlm_res = NTLM::ntlm2_session(ar, opt)
+            ntlmv2_responses(creds, challenge, opt)
+          elsif flag?(:NTLM2_KEY)
+            ntlm2_session_responses(creds, challenge, opt)
           else
-            ar = {:lm_hash => NTLM::lm_hash(pwd), :challenge => chal}
-            lm_res = NTLM::lm_response(ar)
-            ar = {:ntlm_hash => NTLM::ntlm_hash(pwd, opt), :challenge => chal}
-            ntlm_res = NTLM::ntlm_response(ar)
+            v1_responses(creds, challenge, opt)
           end
+        end
 
-          Type3.create({
-                           :lm_response => lm_res,
-                           :ntlm_response => ntlm_res,
-                           :domain => domain,
-                           :user => usr,
-                           :workstation => ws,
-                           :flag => self.flag
-                       })
+        def ntlmv2_responses(creds, challenge, opt)
+          ar = { ntlmv2_hash: NTLM.ntlmv2_hash(creds[:user], creds[:password], creds[:domain], opt),
+                 challenge: challenge, target_info: target_info }
+          [NTLM.lmv2_response(ar, opt), NTLM.ntlmv2_response(ar, opt)]
         end
 
-      end
+        def ntlm2_session_responses(creds, challenge, opt)
+          ar = { ntlm_hash: NTLM.ntlm_hash(creds[:password], opt), challenge: challenge }
+          NTLM.ntlm2_session(ar, opt)
+        end
+
+        def v1_responses(creds, challenge, opt)
+          lm_res = NTLM.lm_response({ lm_hash: NTLM.lm_hash(creds[:password]), challenge: challenge })
+          ntlm_res = NTLM.ntlm_response({ ntlm_hash: NTLM.ntlm_hash(creds[:password], opt), challenge: challenge })
+          [lm_res, ntlm_res]
+        end
 
+        def build_type3(creds, lm_res, ntlm_res)
+          Type3.create({
+            lm_response: lm_res,
+            ntlm_response: ntlm_res,
+            domain: creds[:domain],
+            user: creds[:user],
+            workstation: creds[:workstation],
+            flag: flag
+          })
+        end
+      end
     end
   end
 end
-
-

data/lib/net/ntlm/message/type3.rb

@@ -1,20 +1,20 @@
+# frozen_string_literal: true
+
 module Net
   module NTLM
     class Message
-
       # @private false
       class Type3 < Message
-
-        string          :sign,          {:size => 8, :value => SSP_SIGN}
-        int32LE         :type,          {:value => 3}
-        security_buffer :lm_response,   {:value => ""}
-        security_buffer :ntlm_response, {:value => ""}
-        security_buffer :domain,        {:value => ""}
-        security_buffer :user,          {:value => ""}
-        security_buffer :workstation,   {:value => ""}
-        security_buffer :session_key,   {:value => "", :active => false }
-        int32LE         :flag,          {:value => 0, :active => false }
-        string          :os_version,    {:size => 8, :active => false }
+        string :sign, { size: 8, value: SSP_SIGN }
+        int32_le :type, { value: 3 }
+        security_buffer :lm_response,   { value: '' }
+        security_buffer :ntlm_response, { value: '' }
+        security_buffer :domain,        { value: '' }
+        security_buffer :user,          { value: '' }
+        security_buffer :workstation,   { value: '' }
+        security_buffer :session_key,   { value: '', active: false }
+        int32_le :flag, { value: 0, active: false }
+        string :os_version, { size: 8, active: false }
 
         class << Type3
           # Builds a Type 3 packet
@@ -26,28 +26,33 @@ module Net
           # @option arg [String] :workstation The name of the calling workstation
           # @option arg [String] :session_key The session key
           # @option arg [Integer] :flag Flags for the packet
-          def create(arg, opt ={})
+          def create(arg, _opt = {})
             t = new
             t.lm_response = arg[:lm_response]
             t.ntlm_response = arg[:ntlm_response]
             t.domain = arg[:domain]
             t.user = arg[:user]
+            t.workstation = arg[:workstation] if arg[:workstation]
+            enable_session_key(t, arg)
+            enable_flag(t, arg)
+            t
+          end
 
-            if arg[:workstation]
-              t.workstation = arg[:workstation]
-            end
+          private
 
-            if arg[:session_key]
-              t.enable(:session_key)
-              t.session_key = arg[:session_key]
-            end
+          def enable_session_key(type3, arg)
+            return unless arg[:session_key]
 
-            if arg[:flag]
-              t.enable(:session_key)
-              t.enable(:flag)
-              t.flag = arg[:flag]
-            end
-            t
+            type3.enable(:session_key)
+            type3.session_key = arg[:session_key]
+          end
+
+          def enable_flag(type3, arg)
+            return unless arg[:flag]
+
+            type3.enable(:session_key)
+            type3.enable(:flag)
+            type3.flag = arg[:flag]
           end
         end
 
@@ -75,7 +80,7 @@ module Net
 
         # @return [Symbol]
         def ntlm_version
-          if ntlm_response.size == 24 && lm_response[0,8] != "\x00"*8 && lm_response[8,16] == "\x00"*16
+          if ntlm_response.size == 24 && lm_response[0, 8] != "\x00" * 8 && lm_response[8, 16] == "\x00" * 16
             :ntlm2_session
           elsif ntlm_response.size == 24
             :ntlmv1
@@ -87,31 +92,28 @@ module Net
         private
 
         def ntlm2_session_password?(password, server_challenge)
-          hash = ntlm_response
-          _lm, empty_hash = NTLM.ntlm2_session(
-            {
-              :ntlm_hash => NTLM.ntlm_hash(password),
-              :challenge => server_challenge,
-            },
-            {
-              :client_challenge => lm_response[0,8]
-            }
-          )
-          hash == empty_hash
+          ntlm_response == ntlm2_session_empty_hash(password, server_challenge)
+        end
+
+        def ntlm2_session_empty_hash(password, server_challenge)
+          NTLM.ntlm2_session(
+            { ntlm_hash: NTLM.ntlm_hash(password), challenge: server_challenge },
+            { client_challenge: lm_response[0, 8] }
+          ).last
         end
 
         def ntlmv2_password?(password, server_challenge)
           # user and domain are already UTF-16LE from the wire; encode the
           # supplied password to match before deriving the verification key.
-          key = NTLM.ntlmv2_hash(user, EncodeUtil.encode_utf16le(password), domain, :unicode => true)
+          key = NTLM.ntlmv2_hash(user, EncodeUtil.encode_utf16le(password), domain, unicode: true)
           server_challenge = NTLM.pack_int64le(server_challenge) if server_challenge.is_a?(Integer)
 
           # Authenticate the exact blob bytes. Rebuilding the blob truncates
           # sub-second timestamps and rejects otherwise valid responses.
           expected_proof = OpenSSL::HMAC.digest(
-            OpenSSL::Digest::MD5.new, key, server_challenge + ntlm_response[16..-1]
+            OpenSSL::Digest.new('MD5'), key, server_challenge + ntlm_response[16..]
           )
-          expected_proof == ntlm_response[0,16]
+          expected_proof == ntlm_response[0, 16]
         end
       end
     end

data/lib/net/ntlm/message.rb

@@ -1,137 +1,142 @@
+# frozen_string_literal: true
+
 module Net
-module NTLM
-
-  SSP_SIGN = "NTLMSSP\0"
-
-  # See [2.2.2.5 NEGOTIATE](https://msdn.microsoft.com/en-us/library/cc236650.aspx)
-  FLAGS = {
-      :UNICODE              => 0x00000001,
-      :OEM                  => 0x00000002,
-      :REQUEST_TARGET       => 0x00000004,
-      :SIGN                 => 0x00000010,
-      :SEAL                 => 0x00000020,
-      :NEG_DATAGRAM         => 0x00000040,
-      :NEG_LM_KEY           => 0x00000080,
-      :NTLM                 => 0x00000200,
-      :NEG_ANONYMOUS        => 0x00000800,
-      :DOMAIN_SUPPLIED      => 0x00001000,
-      :WORKSTATION_SUPPLIED => 0x00002000,
-      :ALWAYS_SIGN          => 0x00008000,
-      :TARGET_TYPE_DOMAIN   => 0x00010000,
-      :TARGET_TYPE_SERVER   => 0x00020000,
-      :NTLM2_KEY            => 0x00080000,
-      :NEG_IDENTIFY         => 0x00100000,
-      :NON_NT_SESSION_KEY   => 0x00400000,
-      :TARGET_INFO          => 0x00800000,
-      :NEG_VERSION          => 0x02000000,
-      :KEY128               => 0x20000000,
-      :KEY_EXCHANGE         => 0x40000000,
-      :KEY56                => 0x80000000,
+  module NTLM
+    SSP_SIGN = "NTLMSSP\0"
+
+    # See [2.2.2.5 NEGOTIATE](https://msdn.microsoft.com/en-us/library/cc236650.aspx)
+    FLAGS = {
+      UNICODE: 0x00000001,
+      OEM: 0x00000002,
+      REQUEST_TARGET: 0x00000004,
+      SIGN: 0x00000010,
+      SEAL: 0x00000020,
+      NEG_DATAGRAM: 0x00000040,
+      NEG_LM_KEY: 0x00000080,
+      NTLM: 0x00000200,
+      NEG_ANONYMOUS: 0x00000800,
+      DOMAIN_SUPPLIED: 0x00001000,
+      WORKSTATION_SUPPLIED: 0x00002000,
+      ALWAYS_SIGN: 0x00008000,
+      TARGET_TYPE_DOMAIN: 0x00010000,
+      TARGET_TYPE_SERVER: 0x00020000,
+      NTLM2_KEY: 0x00080000,
+      NEG_IDENTIFY: 0x00100000,
+      NON_NT_SESSION_KEY: 0x00400000,
+      TARGET_INFO: 0x00800000,
+      NEG_VERSION: 0x02000000,
+      KEY128: 0x20000000,
+      KEY_EXCHANGE: 0x40000000,
+      KEY56: 0x80000000,
       # Undocumented flags:
-      :MBZ9                 => 0x00000008,
-      :NETWARE              => 0x00000100,
-      :NEG_NT_ONLY          => 0x00000400,
-      :MBZ7                 => 0x00000800, # alias for :NEG_ANONYMOUS
-      :LOCAL_CALL           => 0x00004000,
-  }.freeze
-
-  FLAG_KEYS = FLAGS.keys.sort{|a, b| FLAGS[a] <=> FLAGS[b] }
-
-  DEFAULT_FLAGS = {
-      :TYPE1 => FLAGS[:UNICODE] | FLAGS[:OEM] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] | FLAGS[:NTLM2_KEY],
-      :TYPE2 => FLAGS[:UNICODE],
-      :TYPE3 => FLAGS[:UNICODE] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] | FLAGS[:NTLM2_KEY]
-  }
-
-  # @private false
-  class Message < FieldSet
-    class << Message
+      MBZ9: 0x00000008,
+      NETWARE: 0x00000100,
+      NEG_NT_ONLY: 0x00000400,
+      MBZ7: 0x00000800, # alias for :NEG_ANONYMOUS
+      LOCAL_CALL: 0x00004000
+    }.freeze
+
+    FLAG_KEYS = FLAGS.keys.sort { |a, b| FLAGS[a] <=> FLAGS[b] }.freeze
+
+    DEFAULT_FLAGS = {
+      TYPE1: FLAGS[:UNICODE] | FLAGS[:OEM] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] |
+             FLAGS[:NTLM2_KEY],
+      TYPE2: FLAGS[:UNICODE],
+      TYPE3: FLAGS[:UNICODE] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] | FLAGS[:NTLM2_KEY]
+    }.freeze
+
+    # @private false
+    class Message < FieldSet
+      class << Message
+        def parse(str)
+          m = Type0.new
+          m.parse(str)
+          type_class = { 1 => Type1, 2 => Type2, 3 => Type3 }[m.type]
+          raise ArgumentError, "unknown type: #{m.type}" unless type_class
+
+          type_class.new.parse(str)
+        end
+
+        def decode64(str)
+          parse(Base64.decode64(str))
+        end
+      end
+
+      # @return [self]
       def parse(str)
-        m = Type0.new
-        m.parse(str)
-        case m.type
-        when 1
-          t = Type1.new.parse(str)
-        when 2
-          t = Type2.new.parse(str)
-        when 3
-          t = Type3.new.parse(str)
-        else
-          raise ArgumentError, "unknown type: #{m.type}"
+        super
+
+        while disabled_fields? && serialize.size < str.size
+          enable_next_disabled_field
+          super
         end
-        t
+
+        self
       end
 
-      def decode64(str)
-        parse(Base64.decode64(str))
+      def flag?(flag)
+        (self[:flag].value & FLAGS[flag]) == FLAGS[flag]
       end
-    end
 
-    # @return [self]
-    def parse(str)
-      super
+      alias has_flag? flag?
 
-      while has_disabled_fields? && serialize.size < str.size
-        # enable the next disabled field
-        self.class.names.find { |name| !self[name].active && enable(name) }
-        super
+      def flag=(flag)
+        self[:flag].value |= FLAGS[flag]
       end
 
-      self
-    end
-
-    def has_flag?(flag)
-      (self[:flag].value & FLAGS[flag]) == FLAGS[flag]
-    end
+      alias set_flag flag=
 
-    def set_flag(flag)
-      self[:flag].value  |= FLAGS[flag]
-    end
+      def dump_flags
+        FLAG_KEYS.each { |k| print(k, '=', flag?(k), "\n") }
+      end
 
-    def dump_flags
-      FLAG_KEYS.each{ |k| print(k, "=", has_flag?(k), "\n") }
-    end
+      def serialize
+        deflag
+        super + security_buffers.map { |_n, f|
+          f.value + (flag?(:UNICODE) ? "\x00".b * (f.value.length % 2) : '')
+        }.join
+      end
 
-    def serialize
-      deflag
-      super + security_buffers.map{|n, f| f.value + (has_flag?(:UNICODE) ? "\x00".b * (f.value.length % 2) : '')}.join
-    end
+      def encode64
+        Base64.encode64(serialize).gsub(/\n/, '')
+      end
 
-    def encode64
-      Base64.encode64(serialize).gsub(/\n/, '')
-    end
+      def decode64(str)
+        parse(Base64.decode64(str))
+      end
 
-    def decode64(str)
-      parse(Base64.decode64(str))
-    end
+      alias head_size size
 
-    alias head_size size
+      def data_size
+        security_buffers.inject(0) { |sum, a| sum + a[1].data_size }
+      end
 
-    def data_size
-      security_buffers.inject(0){|sum, a| sum += a[1].data_size}
-    end
+      def size
+        head_size + data_size
+      end
 
-    def size
-      head_size + data_size
-    end
+      def security_buffers
+        @alist.find_all { |_n, f| f.instance_of?(SecurityBuffer) }
+      end
 
+      def deflag
+        security_buffers.inject(head_size) { |cur, a|
+          a[1].offset = cur
+          cur += a[1].data_size
+          flag?(:UNICODE) ? cur + cur % 2 : cur
+        }
+      end
 
-    def security_buffers
-      @alist.find_all{|n, f| f.instance_of?(SecurityBuffer)}
-    end
+      def data_edge
+        security_buffers.map { |_n, f| f.active ? f.offset : size }.min
+      end
 
-    def deflag
-      security_buffers.inject(head_size){|cur, a|
-        a[1].offset = cur
-        cur += a[1].data_size
-        has_flag?(:UNICODE) ? cur + cur % 2 : cur
-      }
-    end
+      private
 
-    def data_edge
-      security_buffers.map{ |n, f| f.active ? f.offset : size}.min
+      # enable the next disabled field
+      def enable_next_disabled_field
+        self.class.names.find { |name| !self[name].active && enable(name) }
+      end
     end
-
   end
 end
-end