rubyntlm 0.3.4 → 0.4.0

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

@@ -0,0 +1,126 @@
+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        :padding,   {:size => 0, :value => "", :active => false }
+
+        class << Type2
+          # Parse a Type 2 packet
+          # @param [String] str A string containing Type 2 data
+          # @return [Type2]
+          def parse(str)
+            t = new
+            t.parse(str)
+            t
+          end
+        end
+
+        # @!visibility private
+        def parse(str)
+          super(str)
+          if has_flag?(:TARGET_INFO)
+            enable(:context)
+            enable(:target_info)
+            super(str)
+          end
+          if ( (len = data_edge - head_size) > 0)
+            self.padding = "\0" * len
+            super(str)
+          end
+        end
+
+        # 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 presidence 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
+            lm_res = NTLM::lm_response(pwd, chal)
+            ntlm_res = NTLM::ntlm_response(pwd, chal)
+          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
+
+

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

@@ -0,0 +1,68 @@
+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 }
+        int64LE         :flag,          {:value => 0, :active => false }
+
+        class << Type3
+          # Parse a Type 3 packet
+          # @param [String] str A string containing Type 3 data
+          # @return [Type2]
+          def parse(str)
+            t = new
+            t.parse(str)
+            t
+          end
+
+          # Builds a Type 3 packet
+          # @note All options must be properly encoded with either unicode or oem encoding
+          # @return [Type3]
+          # @option arg [String] :lm_response The LM hash
+          # @option arg [String] :ntlm_response The NTLM hash
+          # @option arg [String] :domain The domain to authenticate to
+          # @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 ={})
+            t = new
+            t.lm_response = arg[:lm_response]
+            t.ntlm_response = arg[:ntlm_response]
+            t.domain = arg[:domain]
+            t.user = arg[:user]
+
+            if arg[:workstation]
+              t.workstation = arg[:workstation]
+            end
+
+            if arg[:session_key]
+              t.enable(:session_key)
+              t.session_key = arg[session_key]
+            end
+
+            if arg[:flag]
+              t.enable(:session_key)
+              t.enable(:flag)
+              t.flag = arg[:flag]
+            end
+            t
+          end
+        end
+      end
+
+
+    end
+  end
+end
+
+

data/lib/net/ntlm/security_buffer.rb

@@ -0,0 +1,48 @@
+
+module Net
+  module NTLM
+
+    class SecurityBuffer < FieldSet
+
+      int16LE   :length,        {:value => 0}
+      int16LE   :allocated,     {:value => 0}
+      int32LE   :offset,        {:value => 0}
+
+      attr_accessor :active
+      def initialize(opts={})
+        super()
+        @value  = opts[:value]
+        @active = opts[:active].nil? ? true : opts[:active]
+        @size = 8
+      end
+
+      def parse(str, offset=0)
+        if @active and str.size >= offset + @size
+          super(str, offset)
+          @value = str[self.offset, self.length]
+          @size
+        else
+          0
+        end
+      end
+
+      def serialize
+        super if @active
+      end
+
+      def value
+        @value
+      end
+
+      def value=(val)
+        @value = val
+        self.length = self.allocated = val.size
+      end
+
+      def data_size
+        @active ? @value.size : 0
+      end
+    end
+
+  end
+end

data/lib/net/ntlm/string.rb

@@ -0,0 +1,35 @@
+module Net
+  module NTLM
+
+    class String < Field
+      def initialize(opts)
+        super(opts)
+        @size = opts[:size]
+      end
+
+      def parse(str, offset=0)
+        if @active and str.size >= offset + @size
+          @value = str[offset, @size]
+          @size
+        else
+          0
+        end
+      end
+
+      def serialize
+        if @active
+          @value.to_s
+        else
+          ""
+        end
+      end
+
+      def value=(val)
+        @value = val
+        @size = @value.nil? ? 0 : @value.size
+        @active = (@size > 0)
+      end
+    end
+
+  end
+end

data/lib/net/ntlm/version.rb

@@ -0,0 +1,11 @@
+module Net
+  module NTLM
+    # @private
+    module VERSION
+      MAJOR = 0
+      MINOR = 4
+      TINY  = 0
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+end

data/rubyntlm.gemspec

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'lib', 'net', 'ntlm')
+require File.join(File.dirname(__FILE__), 'lib', 'net', 'ntlm', 'version')
 
 Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
@@ -18,7 +18,10 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.required_ruby_version = '>= 1.8.7'
+  
+  s.license = 'MIT'
 
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov"
 end

data/spec/lib/net/ntlm/blob_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Net::NTLM::Blob do
+
+  fields = [
+      { :name => :blob_signature, :class => Net::NTLM::Int32LE, :value => 257, :active => true },
+      { :name => :reserved, :class => Net::NTLM::Int32LE, :value => 0, :active => true },
+      { :name => :timestamp, :class => Net::NTLM::Int64LE, :value => 0, :active => true },
+      { :name => :challenge, :class => Net::NTLM::String, :value => '', :active => true },
+      { :name => :unknown1, :class => Net::NTLM::Int32LE, :value => 0, :active => true },
+      { :name => :target_info, :class => Net::NTLM::String, :value => '', :active => true },
+      { :name => :unknown2, :class => Net::NTLM::Int32LE, :value => 0, :active => true },
+  ]
+
+  it_behaves_like 'a fieldset', fields
+end

data/spec/lib/net/ntlm/encode_util_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Net::NTLM::EncodeUtil do
+
+  context '#encode_utf16le' do
+    it 'should convert an ASCII string to UTF' do
+      Net::NTLM::EncodeUtil.encode_utf16le('Test').should == "T\x00e\x00s\x00t\x00"
+    end
+  end
+
+  context '#decode_utf16le' do
+    it 'should convert a UTF string to ASCII' do
+      Net::NTLM::EncodeUtil.decode_utf16le("T\x00e\x00s\x00t\x00").should == 'Test'
+    end
+  end
+end

data/spec/lib/net/ntlm/field_set_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Net::NTLM::FieldSet do
+
+  fields = []
+
+  it_behaves_like 'a fieldset', fields
+
+  subject(:fieldset_class) do
+    Class.new(Net::NTLM::FieldSet)
+  end
+
+  context 'an instance' do
+    subject(:fieldset_object) do
+      fieldset_class.string(:test_string, { :value => 'Test', :active => true, :size => 4})
+      fieldset_class.string(:test_string2, { :value => 'Foo', :active => true, :size => 3})
+      fieldset_class.new
+    end
+
+    it 'should serialize all the fields' do
+      fieldset_object.serialize.should == 'TestFoo'
+    end
+
+    it 'should parse a string across the fields' do
+      fieldset_object.parse('FooBarBaz')
+      fieldset_object.serialize.should == 'FooBarB'
+    end
+
+    it 'should return an aggregate size of all the fields' do
+      fieldset_object.size.should == 7
+    end
+  end
+end

data/spec/lib/net/ntlm/field_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Net::NTLM::Field do
+
+  it_behaves_like 'a field', 'Foo', false
+
+  context 'with no size specified' do
+    let (:field_without_size) { Net::NTLM::Field.new({ :value => 'Foo', :active => true }) }
+    it 'should set size to 0 if not active' do
+      field_without_size.size.should == 0
+    end
+
+    it 'should return 0 if active but no size specified' do
+      field_without_size.active = true
+      field_without_size.size.should == 0
+    end
+  end
+
+  context 'with a size specified' do
+    let (:field_with_size) { Net::NTLM::Field.new({ :value => 'Foo', :active => true, :size => 100 }) }
+
+    it 'should return the size provided in the initialize options if active' do
+      field_with_size.size.should == 100
+    end
+
+    it 'should still return 0 if not active' do
+      field_with_size.active = false
+      field_with_size.size.should == 0
+    end
+  end
+
+
+
+end

data/spec/lib/net/ntlm/int16_le_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Net::NTLM::Int16LE do
+
+  int_values = {
+    :default     => 15,
+    :default_hex => "\x0F\x00",
+    :alt         => 14,
+    :alt_hex     => "\x0E\x00",
+    :small       => "\x0F",
+    :size        => 2,
+    :bits        => 16
+  }
+
+  it_behaves_like 'a field', 15, false
+  it_behaves_like 'an integer field', int_values
+
+end

data/spec/lib/net/ntlm/int32_le_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Net::NTLM::Int32LE do
+
+  int_values = {
+      :default     => 252716124,
+      :default_hex => "\x5C\x24\x10\x0f",
+      :alt         => 235938908,
+      :alt_hex     => "\x5C\x24\x10\x0e",
+      :small       => "\x0F\x00",
+      :size        => 4,
+      :bits        => 32
+  }
+
+
+  it_behaves_like 'a field', 252716124, false
+  it_behaves_like 'an integer field', int_values
+
+end