rubyntlm 0.2.0 → 0.3.0

data/.gitignore

@@ -0,0 +1,2 @@
+.yardoc
+/doc

data/.travis.yml

@@ -2,11 +2,5 @@ language: ruby
 rvm:
   - 1.9.3
   - 1.9.2
-  - jruby-18mode
-  - jruby-19mode
-  - rbx-18mode
   - rbx-19mode
-  - ruby-head
-  - jruby-head
-  - 1.8.7
-  - ree
+  - ruby-head

data/Gemfile

@@ -1,3 +1,3 @@
 source 'https://rubygems.org'
 
-gemspec
+gemspec

data/Gemfile.lock

@@ -1,17 +1,27 @@
 PATH
   remote: .
   specs:
-    rubyntlm (0.2.0)
+    rubyntlm (0.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    diff-lcs (1.2.1)
     rake (10.0.3)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.0)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.3)
   rake
+  rspec
   rubyntlm!

data/README.md

@@ -1,6 +1,6 @@
 # Ruby/NTLM -- NTLM Authentication Library for Ruby
 
-[![Build Status](https://travis-ci.org/winrb/[rubyntlm].png)](https://travis-ci.org/winrb/rubyntlm)
+[![Build Status](https://travis-ci.org/WinRb/rubyntlm.png)](https://travis-ci.org/WinRb/rubyntlm)
 
 Ruby/NTLM provides message creator and parser for the NTLM authentication. 
 

data/Rakefile

@@ -1,10 +1,21 @@
 require "bundler/gem_tasks"
-require 'rake/testtask'
 
-task :default => [:test]
+task :default => [:spec]
 
-Rake::TestTask.new(:test) do |t|
-  t.test_files = FileList[ "test/*.rb" ]
-  t.warning = true
-  t.verbose = true
+
+require 'rspec/core/rake_task'
+ 
+desc 'Default: run specs.'
+task :default => :spec
+ 
+desc "Run specs unit tests"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/unit/*_spec.rb" 
 end
+ 
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/unit/*_spec.rb"  # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end

data/lib/net/ntlm.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 #
 # = net/ntlm.rb
 #
@@ -45,15 +46,14 @@
 require 'base64'
 require 'openssl'
 require 'openssl/digest'
-require 'kconv'
 require 'socket'
 
-module Net  #:nodoc:
-  module NTLM #:nodoc:
-
-    module VERSION #:nodoc:
+module Net
+  module NTLM
+    # @private
+    module VERSION
       MAJOR = 0
-      MINOR = 2
+      MINOR = 3
       TINY  = 0
       STRING = [MAJOR, MINOR, TINY].join('.')
     end
@@ -68,14 +68,14 @@ module Net  #:nodoc:
       :UNICODE              => 0x00000001,
       :OEM                  => 0x00000002,
       :REQUEST_TARGET       => 0x00000004,
-  #   :UNKNOWN              => 0x00000008,
+      :MBZ9                 => 0x00000008,
       :SIGN                 => 0x00000010,
       :SEAL                 => 0x00000020,
-  #   :UNKNOWN              => 0x00000040,
+      :NEG_DATAGRAM         => 0x00000040,
       :NETWARE              => 0x00000100,
       :NTLM                 => 0x00000200,
-  #   :UNKNOWN              => 0x00000400,
-  #   :UNKNOWN              => 0x00000800,
+      :NEG_NT_ONLY          => 0x00000400,
+      :MBZ7                 => 0x00000800,
       :DOMAIN_SUPPLIED      => 0x00001000,
       :WORKSTATION_SUPPLIED => 0x00002000,
       :LOCAL_CALL           => 0x00004000,
@@ -85,7 +85,7 @@ module Net  #:nodoc:
       :NTLM2_KEY            => 0x00080000,
       :KEY128               => 0x20000000,
       :KEY56                => 0x80000000
-    }
+    }.freeze
     
     FLAG_KEYS = FLAGS.keys.sort{|a, b| FLAGS[a] <=> FLAGS[b] }
 
@@ -95,24 +95,36 @@ module Net  #:nodoc:
       :TYPE3 => FLAGS[:UNICODE] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] | FLAGS[:NTLM2_KEY]
     }
 
-  # module functions
+
     class << self
+
+      # Decode a UTF16 string to a ASCII string
+      # @param [String] str The string to convert
       def decode_utf16le(str)
-        Kconv.kconv(swap16(str), Kconv::ASCII, Kconv::UTF16)
+        str.encode(Encoding::UTF_8, Encoding::UTF_16LE).force_encoding('UTF-8')
       end
 
+      # Encodes a ASCII string to a UTF16 string
+      # @param [String] str The string to convert
+      # @note This implementation may seem stupid but the problem is that UTF16-LE and UTF-8 are incompatiable
+      #   encodings. This library uses string contatination to build the packet bytes. The end result is that 
+      #   you can either marshal the encodings elsewhere of simply know that each time you call encode_utf16le
+      #   the function will convert the string bytes to UTF-16LE and note the encoding as UTF-8 so that byte 
+      #   concatination works seamlessly.
       def encode_utf16le(str)
-        swap16(Kconv.kconv(str, Kconv::UTF16, Kconv::ASCII))
+        str = str.force_encoding('UTF-8') if [::Encoding::ASCII_8BIT,::Encoding::US_ASCII].include?(str.encoding)
+        str.force_encoding('UTF-8').encode(Encoding::UTF_16LE, Encoding::UTF_8).force_encoding('UTF-8')
       end
-    
+      
+      # Conver the value to a 64-Bit Little Endian Int
+      # @param [String] val The string to convert
       def pack_int64le(val)
           [val & 0x00000000ffffffff, val >> 32].pack("V2")
       end
-      
-      def swap16(str)
-        str.unpack("v*").pack("n*")
-      end
 
+      # Builds an array of strings that are 7 characters long
+      # @param [String] str The string to split
+      # @api private
       def split7(str)
         s = str.dup
         until s.empty?
@@ -120,7 +132,10 @@ module Net  #:nodoc:
         end
         ret
       end
-    
+      
+      # Not sure what this is doing
+      # @param [String] str String to generate keys for
+      # @api private
       def gen_keys(str)
         split7(str).map{ |str7| 
           bits = split7(str7.unpack("B*")[0]).inject('')\
@@ -137,11 +152,16 @@ module Net  #:nodoc:
         }
       end
       
+      # Generates a Lan Manager Hash
+      # @param [String] password The password to base the hash on
       def lm_hash(password)
         keys = gen_keys password.upcase.ljust(14, "\0")
         apply_des(LM_MAGIC, keys).join
       end   
       
+      # Generate a NTLM Hash
+      # @param [String] password The password to base the hash on
+      # @option opt :unicode (false) Unicode encode the password
       def ntlm_hash(password, opt = {})
         pwd = password.dup
         unless opt[:unicode]
@@ -150,6 +170,11 @@ module Net  #:nodoc:
         OpenSSL::Digest::MD4.digest pwd
       end
 
+      # Generate a NTLMv2 Hash
+      # @param [String] user The username
+      # @param [String] password The password
+      # @param [String] target The domain or workstaiton to authenticate to
+      # @option opt :unicode (false) Unicode encode the domain
       def ntlmv2_hash(user, password, target, opt={})
         ntlmhash = ntlm_hash(password, opt)
         userdomain = (user + target).upcase
@@ -159,7 +184,6 @@ module Net  #:nodoc:
         OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, ntlmhash, userdomain)
       end
 
-      # responses
       def lm_response(arg)
         begin
           hash = arg[:lm_hash]
@@ -254,6 +278,7 @@ module Net  #:nodoc:
 
 
     # base classes for primitives
+    # @private
     class Field
       attr_accessor :active, :value
 
@@ -297,7 +322,6 @@ module Net  #:nodoc:
       end
     end
 
-
     class Int16LE < Field
       def initialize(opt)
         super(opt)
@@ -361,34 +385,44 @@ module Net  #:nodoc:
     # base class of data structure
     class FieldSet
       class << FieldSet
-        def define(&block)
-          c = Class.new(self)
-          def c.inherited(subclass)
-            proto = @proto
-            subclass.instance_eval {
-              @proto = proto
-            }
-          end
-          c.module_eval(&block)
-          c
-        end
         
+        
+        # @macro string_security_buffer
+        #   @method $1
+        #   @method $1=
+        #   @return [String]
         def string(name, opts)
           add_field(name, String, opts)
         end
         
+        # @macro int16le_security_buffer
+        #   @method $1
+        #   @method $1=
+        #   @return [Int16LE]
         def int16LE(name, opts)
           add_field(name, Int16LE, opts)
         end
 
+        # @macro int32le_security_buffer
+        #   @method $1
+        #   @method $1=
+        #   @return [Int32LE]
         def int32LE(name, opts)
           add_field(name, Int32LE, opts)
         end
 
+        # @macro int64le_security_buffer
+        #   @method $1
+        #   @method $1=
+        #   @return [Int64]
         def int64LE(name, opts)
           add_field(name, Int64LE, opts)
         end
         
+        # @macro security_buffer
+        #   @method $1
+        #   @method $1=
+        #   @return [SecurityBuffer]
         def security_buffer(name, opts)
           add_field(name, SecurityBuffer, opts)
         end
@@ -466,8 +500,7 @@ module Net  #:nodoc:
       end
     end
 
-
-    Blob = FieldSet.define {
+    class Blob < FieldSet
       int32LE    :blob_signature,   {:value => BLOB_SIGN}
       int32LE    :reserved,         {:value => 0}
       int64LE    :timestamp,      {:value => 0}
@@ -475,15 +508,14 @@ module Net  #:nodoc:
       int32LE    :unknown1,     {:value => 0}
       string     :target_info,      {:value => "", :size => 0}
       int32LE    :unknown2,         {:value => 0}
-    }
+    end
+
+    class SecurityBuffer < FieldSet
 
-    SecurityBuffer = FieldSet.define {
       int16LE   :length,        {:value => 0}
       int16LE   :allocated,     {:value => 0}
       int32LE   :offset,        {:value => 0}
-    }
 
-    class SecurityBuffer
       attr_accessor :active
       def initialize(opts)
         super()
@@ -519,7 +551,8 @@ module Net  #:nodoc:
         @active ? @value.size : 0
       end
     end
-    
+
+    # @private false
     class Message < FieldSet
       class << Message
         def parse(str)
@@ -579,8 +612,6 @@ module Net  #:nodoc:
       end
       
 
-      private
-
       def security_buffers
         @alist.find_all{|n, f| f.instance_of?(SecurityBuffer)}
       end
@@ -597,23 +628,25 @@ module Net  #:nodoc:
       end
 
       # sub class definitions
-      
-      Type0 = Message.define {
+      class Type0 < Message
         string        :sign,      {:size => 8, :value => SSP_SIGN}
         int32LE       :type,      {:value => 0}
-      }
-      
-      Type1 = Message.define {
+      end
+
+      # @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          :padding,      {:size => 0, :value => "", :active => false }
-      }
 
-      class Type1
         class << Type1
+          # Parses a Type 1 Message
+          # @param [String] str A string containing Type 1 data 
+          # @return [Type1] The parsed Type 1 message
           def parse(str)
             t = new
             t.parse(str)
@@ -621,6 +654,7 @@ module Net  #:nodoc:
           end
         end
         
+        # @!visibility private
         def parse(str)
           super(str)
           enable(:domain) if has_flag?(:DOMAIN_SUPPLIED)
@@ -633,7 +667,10 @@ module Net  #:nodoc:
         end
       end
       
-      Type2 = Message.define{
+
+      # @private false
+      class Type2 < Message
+
         string        :sign,         {:size => 8, :value => SSP_SIGN}
         int32LE       :type,      {:value => 2}
         security_buffer   :target_name,  {:size => 0, :value => ""}
@@ -642,17 +679,19 @@ module Net  #:nodoc:
         int64LE           :context,      {:value => 0, :active => false}
         security_buffer   :target_info,  {:value => "", :active => false}
         string        :padding,   {:size => 0, :value => "", :active => false }
-      }
-      
-      class Type2
+
         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)
@@ -665,7 +704,16 @@ module Net  #:nodoc:
             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]
@@ -677,7 +725,7 @@ module Net  #:nodoc:
           if opt[:workstation]
             ws = opt[:workstation]
           else
-            ws = ""
+            ws = Socket.gethostname
           end
           
           if opt[:client_challenge]
@@ -692,6 +740,7 @@ module Net  #:nodoc:
             usr = NTLM::decode_utf16le(usr)
             pwd = NTLM::decode_utf16le(pwd)
             ws  = NTLM::decode_utf16le(ws)
+            domain = NTLM::decode_utf16le(domain)
             opt[:unicode] = false
           end
 
@@ -699,9 +748,14 @@ module Net  #:nodoc:
             usr = NTLM::encode_utf16le(usr)
             pwd = NTLM::encode_utf16le(pwd)
             ws  = NTLM::encode_utf16le(ws)
+            domain = NTLM::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
@@ -729,8 +783,9 @@ module Net  #:nodoc:
         end
       end
       
-            
-      Type3 = Message.define{
+      # @private false
+      class Type3 < Message
+
         string          :sign,          {:size => 8, :value => SSP_SIGN}
         int32LE         :type,          {:value => 3}
         security_buffer :lm_response,   {:value => ""}
@@ -740,16 +795,26 @@ module Net  #:nodoc:
         security_buffer :workstation,   {:value => ""}
         security_buffer :session_key,   {:value => "", :active => false }
         int64LE         :flag,          {:value => 0, :active => false }
-      }
-      
-      class Type3
+
         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]
@@ -759,14 +824,13 @@ module Net  #:nodoc:
 
             if arg[:workstation]
               t.workstation = arg[:workstation] 
-            else
-              t.workstation = NTLM.encode_utf16le(Socket.gethostname)
             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)

data/rubyntlm.gemspec

@@ -16,7 +16,9 @@ Gem::Specification.new do |s|
   s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
+  
+  s.required_ruby_version = '1.9.2'
 
-  s.add_development_dependency "bundler", "~> 1.3"
   s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
 end

data/spec/unit/ntlm_spec.rb

@@ -0,0 +1,175 @@
+# encoding: UTF-8
+$:.unshift(File.expand_path(File.dirname(__FILE__) << '../lib'))
+require 'net/ntlm'
+
+describe Net::NTLM::Message do
+  let(:type1_packet) {"TlRMTVNTUAABAAAAB4IIAAAAAAAgAAAAAAAAACAAAAA="}
+  let(:type2_packet) {"TlRMTVNTUAACAAAAHAAcADgAAAAFgooCJ+UA1//+ZM4AAAAAAAAAAJAAkABUAAAABgGxHQAAAA9WAEEARwBSAEEATgBUAC0AMgAwADAAOABSADIAAgAcAFYAQQBHAFIAQQBOAFQALQAyADAAMAA4AFIAMgABABwAVgBBAEcAUgBBAE4AVAAtADIAMAAwADgAUgAyAAQAHAB2AGEAZwByAGEAbgB0AC0AMgAwADAAOABSADIAAwAcAHYAYQBnAHIAYQBuAHQALQAyADAAMAA4AFIAMgAHAAgAZBMdFHQnzgEAAAAA"}
+  let(:type3_packet) {"TlRMTVNTUAADAAAAGAAYAEQAAADAAMAAXAAAAAAAAAAcAQAADgAOABwBAAAUABQAKgEAAAAAAAA+AQAABYKKAgAAAADVS27TfQGmWxSSbXmolTUQyxJmD8ISQuBKKHFKC8GksUZISYc8Ps9RAQEAAAAAAAAANasTdCfOAcsSZg/CEkLgAAAAAAIAHABWAEEARwBSAEEATgBUAC0AMgAwADAAOABSADIAAQAcAFYAQQBHAFIAQQBOAFQALQAyADAAMAA4AFIAMgAEABwAdgBhAGcAcgBhAG4AdAAtADIAMAAwADgAUgAyAAMAHAB2AGEAZwByAGEAbgB0AC0AMgAwADAAOABSADIABwAIAGQTHRR0J84BAAAAAAAAAAB2AGEAZwByAGEAbgB0AGsAbwBiAGUALgBsAG8AYwBhAGwA"}
+  describe Net::NTLM::Message::Type1 do
+    it 'should deserialize' do
+      t1 =  Net::NTLM::Message.decode64(type1_packet)
+      t1.class.should == Net::NTLM::Message::Type1
+      t1.domain.should == ''
+      t1.flag.should == 557575
+      t1.padding.should == ''
+      t1.sign.should  == "NTLMSSP\0"
+      t1.type.should == 1
+      t1.workstation.should == ''
+    end
+
+    it 'should serialize' do
+      t1 = Net::NTLM::Message::Type1.new
+      t1.workstation = ''
+      t1.encode64.should == type1_packet
+    end
+  end
+
+  describe Net::NTLM::Message::Type2 do
+    it 'should deserialize' do
+      t2 =  Net::NTLM::Message.decode64(type2_packet)
+      t2.class.should == Net::NTLM::Message::Type2
+      t2.challenge.should == 14872292244261496103
+      t2.context.should == 0
+      t2.flag.should == 42631685
+      t2.padding.should == ("\x06\x01\xB1\x1D\0\0\0\x0F".force_encoding('ASCII-8BIT'))
+      t2.sign.should == "NTLMSSP\0"
+      Net::NTLM.decode_utf16le(t2.target_info).should == "\u0002\u001CVAGRANT-2008R2\u0001\u001CVAGRANT-2008R2\u0004\u001Cvagrant-2008R2\u0003\u001Cvagrant-2008R2\a\b፤ᐝ❴ǎ\0\0"
+      Net::NTLM.decode_utf16le(t2.target_name).should == "VAGRANT-2008R2"
+      t2.type.should == 2
+    end
+
+    it 'should serialize' do
+      source = Net::NTLM::Message.decode64(type2_packet)
+
+      t2 =  Net::NTLM::Message::Type2.new
+      t2.challenge = source.challenge
+      t2.context = source.context
+      t2.flag = source.flag
+      t2.padding = source.padding
+      t2.sign = source.sign
+      t2.target_info = source.target_info
+      t2.target_name = source.target_name
+      t2.type = source.type
+      t2.enable(:context)
+      t2.enable(:target_info)
+      t2.enable(:padding)
+
+      t2.encode64.should == type2_packet
+    end
+
+    it 'should generate a type 3 response' do
+      t2 = Net::NTLM::Message.decode64(type2_packet)
+
+      type3_known = Net::NTLM::Message.decode64(type3_packet)
+      type3_known.flag = 0x028a8205
+      type3_known.enable(:session_key)
+      type3_known.enable(:flag)
+
+      t3 = t2.response({:user => 'vagrant', :password => 'vagrant', :domain => ''}, {:ntlmv2 => true, :workstation => 'kobe.local'})
+      t3.domain.should == type3_known.domain
+      t3.flag.should == type3_known.flag
+      t3.sign.should == "NTLMSSP\0"
+      t3.workstation.should == "k\0o\0b\0e\0.\0l\0o\0c\0a\0l\0"
+      t3.user.should == "v\0a\0g\0r\0a\0n\0t\0"
+      t3.session_key.should == ''
+    end
+  end
+end
+
+
+describe Net::NTLM do
+  let(:passwd) {"SecREt01"}
+  let(:user) {"user"}
+  let(:domain) {"domain"}
+  let(:challenge) {["0123456789abcdef"].pack("H*")}
+  let(:client_ch) {["ffffff0011223344"].pack("H*")}
+  let(:timestamp) {1055844000}
+  let(:trgt_info) {[
+      "02000c0044004f004d00410049004e00" + 
+      "01000c00530045005200560045005200" +
+      "0400140064006f006d00610069006e00" +
+      "2e0063006f006d000300220073006500" +
+      "72007600650072002e0064006f006d00" +
+      "610069006e002e0063006f006d000000" +
+      "0000"
+     ].pack("H*")}
+
+  it 'should generate an lm_hash' do
+    Net::NTLM::lm_hash(passwd).should == ["ff3750bcc2b22412c2265b23734e0dac"].pack("H*")
+  end
+
+  it 'should generate an ntlm_hash' do
+     Net::NTLM::ntlm_hash(passwd).should == ["cd06ca7c7e10c99b1d33b7485a2ed808"].pack("H*") 
+  end
+
+  it 'should generate an ntlmv2_hash' do
+    Net::NTLM::ntlmv2_hash(user, passwd, domain).should == ["04b8e0ba74289cc540826bab1dee63ae"].pack("H*")
+  end
+
+  it 'should generate an lm_response' do
+    Net::NTLM::lm_response(
+      {
+        :lm_hash => Net::NTLM::lm_hash(passwd),
+        :challenge => challenge
+      }
+    ).should == ["c337cd5cbd44fc9782a667af6d427c6de67c20c2d3e77c56"].pack("H*")
+  end
+
+  it 'should generate an ntlm_response' do
+    ntlm_hash = Net::NTLM::ntlm_hash(passwd)
+    Net::NTLM::ntlm_response(
+      {
+        :ntlm_hash => ntlm_hash,
+        :challenge => challenge
+      }
+    ).should == ["25a98c1c31e81847466b29b2df4680f39958fb8c213a9cc6"].pack("H*")
+  end
+
+  it 'should generate a lvm2_response' do
+    Net::NTLM::lmv2_response(
+      {
+        :ntlmv2_hash => Net::NTLM::ntlmv2_hash(user, passwd, domain),
+        :challenge => challenge
+      },
+      { :client_challenge => client_ch }
+    ).should == ["d6e6152ea25d03b7c6ba6629c2d6aaf0ffffff0011223344"].pack("H*")
+  end
+
+  it 'should generate a ntlmv2_response' do
+    Net::NTLM::ntlmv2_response(
+      {
+        :ntlmv2_hash => Net::NTLM::ntlmv2_hash(user, passwd, domain),
+        :challenge => challenge,
+        :target_info => trgt_info
+      },
+      {
+        :timestamp => timestamp,
+        :client_challenge => client_ch
+      }
+    ).should == [
+      "cbabbca713eb795d04c97abc01ee4983" +
+        "01010000000000000090d336b734c301" +
+        "ffffff00112233440000000002000c00" +
+      "44004f004d00410049004e0001000c00" +
+        "53004500520056004500520004001400" +
+        "64006f006d00610069006e002e006300" +
+        "6f006d00030022007300650072007600" +
+        "650072002e0064006f006d0061006900" +
+        "6e002e0063006f006d00000000000000" +
+        "0000"
+      ].pack("H*")
+  end
+
+  it 'should generate a ntlm2_session' do
+    session = Net::NTLM::ntlm2_session(
+      {
+        :ntlm_hash => Net::NTLM::ntlm_hash(passwd),
+        :challenge => challenge
+      },
+      { :client_challenge => client_ch }
+    )
+    session[0].should == ["ffffff001122334400000000000000000000000000000000"].pack("H*")
+    session[1].should == ["10d550832d12b2ccb79d5ad1f4eed3df82aca4c3681dd455"].pack("H*")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyntlm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,26 +10,26 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-22 00:00:00.000000000 Z
+date: 2013-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -52,6 +52,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
 - .travis.yml
 - CHANGELOG.md
 - Gemfile
@@ -64,7 +65,7 @@ files:
 - lib/net/ntlm.rb
 - lib/rubyntlm.rb
 - rubyntlm.gemspec
-- test/function_test.rb
+- spec/unit/ntlm_spec.rb
 homepage: https://github.com/winrb/rubyntlm
 licenses: []
 post_install_message: 
@@ -74,12 +75,9 @@ require_paths:
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - '>='
+  - - '='
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -254558294721854043
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -88,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -254558294721854043
+      hash: -473842116073612192
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -96,4 +94,4 @@ signing_key:
 specification_version: 3
 summary: Ruby/NTLM library.
 test_files:
-- test/function_test.rb
+- spec/unit/ntlm_spec.rb

data/test/function_test.rb

@@ -1,111 +0,0 @@
-# $Id$
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'test/unit'
-require 'net/ntlm'
-
-class FunctionTest < Test::Unit::TestCase #:nodoc:
-	def setup
-		@passwd = "SecREt01"
-		@user   = "user"
-		@domain = "domain"
-		@challenge = ["0123456789abcdef"].pack("H*")
-		@client_ch = ["ffffff0011223344"].pack("H*")
-		@timestamp = 1055844000
-	   @trgt_info = [
-	   	"02000c0044004f004d00410049004e00" + 
-	   	"01000c00530045005200560045005200" +
-	   	"0400140064006f006d00610069006e00" +
-	   	"2e0063006f006d000300220073006500" +
-	   	"72007600650072002e0064006f006d00" +
-	   	"610069006e002e0063006f006d000000" +
-	   	"0000"
-	   ].pack("H*")
-	end
-
-	def test_lm_hash
-		ahash = ["ff3750bcc2b22412c2265b23734e0dac"].pack("H*")
-		assert_equal ahash, Net::NTLM::lm_hash(@passwd)
-	end
-
-	def test_ntlm_hash
-		ahash = ["cd06ca7c7e10c99b1d33b7485a2ed808"].pack("H*")
-		assert_equal ahash, Net::NTLM::ntlm_hash(@passwd)
-	end
-
-	def test_ntlmv2_hash
-		ahash = ["04b8e0ba74289cc540826bab1dee63ae"].pack("H*")
-		assert_equal ahash, Net::NTLM::ntlmv2_hash(@user, @passwd, @domain)
-	end
-	
-	def test_lm_response
-		ares = ["c337cd5cbd44fc9782a667af6d427c6de67c20c2d3e77c56"].pack("H*")
-		assert_equal ares, Net::NTLM::lm_response(
-			{
-				:lm_hash => Net::NTLM::lm_hash(@passwd),
-				:challenge => @challenge
-			}
-		)
-	end
-	
-	def test_ntlm_response
-		ares = ["25a98c1c31e81847466b29b2df4680f39958fb8c213a9cc6"].pack("H*")
-		ntlm_hash = Net::NTLM::ntlm_hash(@passwd)
-		assert_equal ares, Net::NTLM::ntlm_response(
-			{
-				:ntlm_hash => ntlm_hash,
-				:challenge => @challenge
-			}
-		)
-	end
-
-	def test_lmv2_response
-		ares = ["d6e6152ea25d03b7c6ba6629c2d6aaf0ffffff0011223344"].pack("H*")
-		assert_equal ares, Net::NTLM::lmv2_response(
-			{
-				:ntlmv2_hash => Net::NTLM::ntlmv2_hash(@user, @passwd, @domain),
-				:challenge => @challenge
-			},
-			{ :client_challenge => @client_ch }
-		)
-	end
-	
-	def test_ntlmv2_response
-		ares = [
-			"cbabbca713eb795d04c97abc01ee4983" +
-  			"01010000000000000090d336b734c301" +
-  			"ffffff00112233440000000002000c00" +
-			"44004f004d00410049004e0001000c00" +
-  			"53004500520056004500520004001400" +
-  			"64006f006d00610069006e002e006300" +
-  			"6f006d00030022007300650072007600" +
-  			"650072002e0064006f006d0061006900" +
-  			"6e002e0063006f006d00000000000000" +
-  			"0000"
-  		].pack("H*")
-		assert_equal ares, Net::NTLM::ntlmv2_response(
-			{
-				:ntlmv2_hash => Net::NTLM::ntlmv2_hash(@user, @passwd, @domain),
-				:challenge => @challenge,
-				:target_info => @trgt_info
-			},
-			{
-				:timestamp => @timestamp,
-				:client_challenge => @client_ch
-			}
-		)
-	end
-	
-	def test_ntlm2_session
-		acha = ["ffffff001122334400000000000000000000000000000000"].pack("H*")
-  		ares = ["10d550832d12b2ccb79d5ad1f4eed3df82aca4c3681dd455"].pack("H*")
-		session = Net::NTLM::ntlm2_session(
-			{
-				:ntlm_hash => Net::NTLM::ntlm_hash(@passwd),
-		 		:challenge => @challenge
-		 	},
-			{ :client_challenge => @client_ch }
-		)
-		assert_equal acha, session[0]
-		assert_equal ares, session[1]
-	end
-end