rubyntlm 0.5.3 → 0.6.0

data/lib/net/ntlm/int32_le.rb

@@ -1,25 +1,25 @@
-module Net
-  module NTLM
-
-    class Int32LE < Field
-      def initialize(opt)
-        super(opt)
-        @size = 4
-      end
-
-      def parse(str, offset=0)
-        if @active and str.size >= offset + @size
-          @value = str.slice(offset, @size).unpack("V")[0]
-          @size
-        else
-          0
-        end
-      end
-
-      def serialize
-        [@value].pack("V") if @active
-      end
-    end
-
-  end
+module Net
+  module NTLM
+
+    class Int32LE < Field
+      def initialize(opt)
+        super(opt)
+        @size = 4
+      end
+
+      def parse(str, offset=0)
+        if @active and str.size >= offset + @size
+          @value = str.slice(offset, @size).unpack("V")[0]
+          @size
+        else
+          0
+        end
+      end
+
+      def serialize
+        [@value].pack("V") if @active
+      end
+    end
+
+  end
 end

data/lib/net/ntlm/int64_le.rb

@@ -1,26 +1,26 @@
-module Net
-  module NTLM
-
-    class Int64LE < Field
-      def initialize(opt)
-        super(opt)
-        @size = 8
-      end
-
-      def parse(str, offset=0)
-        if @active and str.size >= offset + @size
-          d, u = str.slice(offset, @size).unpack("V2")
-          @value = (u * 0x100000000 + d)
-          @size
-        else
-          0
-        end
-      end
-
-      def serialize
-        [@value & 0x00000000ffffffff, @value >> 32].pack("V2") if @active
-      end
-    end
-
-  end
+module Net
+  module NTLM
+
+    class Int64LE < Field
+      def initialize(opt)
+        super(opt)
+        @size = 8
+      end
+
+      def parse(str, offset=0)
+        if @active and str.size >= offset + @size
+          d, u = str.slice(offset, @size).unpack("V2")
+          @value = (u * 0x100000000 + d)
+          @size
+        else
+          0
+        end
+      end
+
+      def serialize
+        [@value & 0x00000000ffffffff, @value >> 32].pack("V2") if @active
+      end
+    end
+
+  end
 end

data/lib/net/ntlm/message.rb

@@ -1,129 +1,129 @@
-module Net
-module NTLM
-
-  SSP_SIGN = "NTLMSSP\0"
-
-  FLAGS = {
-      :UNICODE              => 0x00000001,
-      :OEM                  => 0x00000002,
-      :REQUEST_TARGET       => 0x00000004,
-      :MBZ9                 => 0x00000008,
-      :SIGN                 => 0x00000010,
-      :SEAL                 => 0x00000020,
-      :NEG_DATAGRAM         => 0x00000040,
-      :NETWARE              => 0x00000100,
-      :NTLM                 => 0x00000200,
-      :NEG_NT_ONLY          => 0x00000400,
-      :MBZ7                 => 0x00000800,
-      :DOMAIN_SUPPLIED      => 0x00001000,
-      :WORKSTATION_SUPPLIED => 0x00002000,
-      :LOCAL_CALL           => 0x00004000,
-      :ALWAYS_SIGN          => 0x00008000,
-      :TARGET_TYPE_DOMAIN   => 0x00010000,
-      :NTLM2_KEY            => 0x00080000,
-      :TARGET_INFO          => 0x00800000,
-      :KEY128               => 0x20000000,
-      :KEY_EXCHANGE         => 0x40000000,
-      :KEY56                => 0x80000000
-  }.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
-      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}"
-        end
-        t
-      end
-
-      def decode64(str)
-        parse(Base64.decode64(str))
-      end
-    end
-
-    # @return [self]
-    def parse(str)
-      super
-
-      while has_disabled_fields? && serialize.size < str.size
-        # enable the next disabled field
-        self.class.names.find { |name| !self[name].active && enable(name) }
-        super
-      end
-
-      self
-    end
-
-    def has_flag?(flag)
-      (self[:flag].value & FLAGS[flag]) == FLAGS[flag]
-    end
-
-    def set_flag(flag)
-      self[:flag].value  |= FLAGS[flag]
-    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}.join
-    end
-
-    def encode64
-      Base64.encode64(serialize).gsub(/\n/, '')
-    end
-
-    def decode64(str)
-      parse(Base64.decode64(str))
-    end
-
-    alias head_size size
-
-    def data_size
-      security_buffers.inject(0){|sum, a| sum += a[1].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
-      }
-    end
-
-    def data_edge
-      security_buffers.map{ |n, f| f.active ? f.offset : size}.min
-    end
-
-  end
-end
-end
+module Net
+module NTLM
+
+  SSP_SIGN = "NTLMSSP\0"
+
+  FLAGS = {
+      :UNICODE              => 0x00000001,
+      :OEM                  => 0x00000002,
+      :REQUEST_TARGET       => 0x00000004,
+      :MBZ9                 => 0x00000008,
+      :SIGN                 => 0x00000010,
+      :SEAL                 => 0x00000020,
+      :NEG_DATAGRAM         => 0x00000040,
+      :NETWARE              => 0x00000100,
+      :NTLM                 => 0x00000200,
+      :NEG_NT_ONLY          => 0x00000400,
+      :MBZ7                 => 0x00000800,
+      :DOMAIN_SUPPLIED      => 0x00001000,
+      :WORKSTATION_SUPPLIED => 0x00002000,
+      :LOCAL_CALL           => 0x00004000,
+      :ALWAYS_SIGN          => 0x00008000,
+      :TARGET_TYPE_DOMAIN   => 0x00010000,
+      :NTLM2_KEY            => 0x00080000,
+      :TARGET_INFO          => 0x00800000,
+      :KEY128               => 0x20000000,
+      :KEY_EXCHANGE         => 0x40000000,
+      :KEY56                => 0x80000000
+  }.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
+      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}"
+        end
+        t
+      end
+
+      def decode64(str)
+        parse(Base64.decode64(str))
+      end
+    end
+
+    # @return [self]
+    def parse(str)
+      super
+
+      while has_disabled_fields? && serialize.size < str.size
+        # enable the next disabled field
+        self.class.names.find { |name| !self[name].active && enable(name) }
+        super
+      end
+
+      self
+    end
+
+    def has_flag?(flag)
+      (self[:flag].value & FLAGS[flag]) == FLAGS[flag]
+    end
+
+    def set_flag(flag)
+      self[:flag].value  |= FLAGS[flag]
+    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}.join
+    end
+
+    def encode64
+      Base64.encode64(serialize).gsub(/\n/, '')
+    end
+
+    def decode64(str)
+      parse(Base64.decode64(str))
+    end
+
+    alias head_size size
+
+    def data_size
+      security_buffers.inject(0){|sum, a| sum += a[1].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
+      }
+    end
+
+    def data_edge
+      security_buffers.map{ |n, f| f.active ? f.offset : size}.min
+    end
+
+  end
+end
+end

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

@@ -1,16 +1,16 @@
-module Net
-  module NTLM
-    class Message
-
-      # sub class definitions
-      class Type0 < Message
-        string        :sign,      {:size => 8, :value => SSP_SIGN}
-        int32LE       :type,      {:value => 0}
-      end
-
-
-    end
-  end
-end
-
-
+module Net
+  module NTLM
+    class Message
+
+      # sub class definitions
+      class Type0 < Message
+        string        :sign,      {:size => 8, :value => SSP_SIGN}
+        int32LE       :type,      {:value => 0}
+      end
+
+
+    end
+  end
+end
+
+

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

@@ -1,18 +1,18 @@
-module Net
-  module NTLM
-    class Message
-
-      # @private false
-      class Type1 < Message
-
-        string          :sign,         {:size => 8, :value => SSP_SIGN}
-        int32LE         :type,         {:value => 1}
-        int32LE         :flag,         {:value => DEFAULT_FLAGS[:TYPE1] }
-        security_buffer :domain,       {:value => ""}
-        security_buffer :workstation,  {:value => Socket.gethostname }
-        string          :os_version,   {:size => 8, :value => "", :active => false }
-
-      end
-    end
-  end
-end
+module Net
+  module NTLM
+    class Message
+
+      # @private false
+      class Type1 < Message
+
+        string          :sign,         {:size => 8, :value => SSP_SIGN}
+        int32LE         :type,         {:value => 1}
+        int32LE         :flag,         {:value => DEFAULT_FLAGS[:TYPE1] }
+        security_buffer :domain,       {:value => ""}
+        security_buffer :workstation,  {:value => Socket.gethostname }
+        string          :os_version,   {:size => 8, :value => "", :active => false }
+
+      end
+    end
+  end
+end

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

@@ -1,102 +1,102 @@
-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 }
-
-        # Generates a Type 3 response based on the Type 2 Information
-        # @return [Type3]
-        # @option arg [String] :username The username to authenticate with
-        # @option arg [String] :password The user's password
-        # @option arg [String] :domain ('') The domain to authenticate to
-        # @option opt [String] :workstation (Socket.gethostname) The name of the calling workstation
-        # @option opt [Boolean] :use_default_target (false) Use the domain supplied by the server in the Type 2 packet
-        # @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 = {})
-          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
-
-          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
-
-          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
-
-          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
-
-          if opt[:use_default_target]
-            domain = self.target_name
-          end
-
-          ti = self.target_info
-
-          chal = 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)
-          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)
-          end
-
-          Type3.create({
-                           :lm_response => lm_res,
-                           :ntlm_response => ntlm_res,
-                           :domain => domain,
-                           :user => usr,
-                           :workstation => ws,
-                           :flag => self.flag
-                       })
-        end
-
-      end
-
-    end
-  end
-end
-
-
+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 }
+
+        # Generates a Type 3 response based on the Type 2 Information
+        # @return [Type3]
+        # @option arg [String] :username The username to authenticate with
+        # @option arg [String] :password The user's password
+        # @option arg [String] :domain ('') The domain to authenticate to
+        # @option opt [String] :workstation (Socket.gethostname) The name of the calling workstation
+        # @option opt [Boolean] :use_default_target (false) Use the domain supplied by the server in the Type 2 packet
+        # @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 = {})
+          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
+
+          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
+
+          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
+
+          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
+
+          if opt[:use_default_target]
+            domain = self.target_name
+          end
+
+          ti = self.target_info
+
+          chal = 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)
+          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)
+          end
+
+          Type3.create({
+                           :lm_response => lm_res,
+                           :ntlm_response => ntlm_res,
+                           :domain => domain,
+                           :user => usr,
+                           :workstation => ws,
+                           :flag => self.flag
+                       })
+        end
+
+      end
+
+    end
+  end
+end
+
+