rubyntlm 0.5.3 → 0.6.0

data/lib/net/ntlm/version.rb

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

data/rubyntlm.gemspec

@@ -1,28 +1,28 @@
-require File.join(File.dirname(__FILE__), 'lib', 'net', 'ntlm', 'version')
-
-Gem::Specification.new do |s|
-  s.platform = Gem::Platform::RUBY
-  s.name = 'rubyntlm'
-  s.version = Net::NTLM::VERSION::STRING
-  s.summary = 'Ruby/NTLM library.'
-  s.description = 'Ruby/NTLM provides message creator and parser for the NTLM authentication.'
-
-  s.authors = ['Kohei Kajimoto','Paul Morton']
-  s.email = ['koheik@gmail.com','paul.e.morton@gmail.com']
-  s.homepage = 'https://github.com/winrb/rubyntlm'
-
-
-  s.files         = `git ls-files`.split($/)
-  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.8.7'
-
-  s.license = 'MIT'
-
-  s.add_development_dependency "pry"
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec", ">= 2.11"
-  s.add_development_dependency "simplecov"
-end
+require File.join(File.dirname(__FILE__), 'lib', 'net', 'ntlm', 'version')
+
+Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = 'rubyntlm'
+  s.version = Net::NTLM::VERSION::STRING
+  s.summary = 'Ruby/NTLM library.'
+  s.description = 'Ruby/NTLM provides message creator and parser for the NTLM authentication.'
+
+  s.authors = ['Kohei Kajimoto','Paul Morton']
+  s.email = ['koheik@gmail.com','paul.e.morton@gmail.com']
+  s.homepage = 'https://github.com/winrb/rubyntlm'
+
+
+  s.files         = `git ls-files`.split($/)
+  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.8.7'
+
+  s.license = 'MIT'
+
+  s.add_development_dependency "pry"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", ">= 2.11"
+  s.add_development_dependency "simplecov"
+end

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

@@ -1,16 +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
+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/channel_binding_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Net::NTLM::ChannelBinding do
+  let(:certificates_path) { 'spec/support/certificates' }
+  let(:sha_256_path) { File.join(certificates_path, 'sha_256_hash.pem') }
+  let(:sha_256_cert) { OpenSSL::X509::Certificate.new(File.read(sha_256_path)) }  
+  let(:cert_hash) { "\x04\x0E\x56\x28\xEC\x4A\x98\x29\x91\x70\x73\x62\x03\x7B\xB2\x3C".force_encoding(Encoding::ASCII_8BIT) }
+
+  subject { Net::NTLM::ChannelBinding.create(sha_256_cert) }
+
+  describe '#channel_binding_token' do
+
+    it 'returns the correct hash' do
+      expect(subject.channel_binding_token).to eq cert_hash
+    end
+  end
+end

data/spec/lib/net/ntlm/client/session_spec.rb

@@ -1,68 +1,68 @@
-require 'spec_helper'
-
-describe Net::NTLM::Client::Session do
-  let(:t2_challenge) { Net::NTLM::Message.decode64 "TlRMTVNTUAACAAAADAAMADgAAAA1goriAAyk1DmJUnUAAAAAAAAAAFAAUABEAAAABgLwIwAAAA9TAEUAUgBWAEUAUgACAAwAUwBFAFIAVgBFAFIAAQAMAFMARQBSAFYARQBSAAQADABzAGUAcgB2AGUAcgADAAwAcwBlAHIAdgBlAHIABwAIADd7mrNaB9ABAAAAAA==" }
-  let(:inst) { Net::NTLM::Client::Session.new(nil, t2_challenge) }
-  let(:user_session_key) {["3c4918ff0b33e2603e5d7ceaf34bb7d5"].pack("H*")}
-  let(:client_sign_key) {["f7f97a82ec390f9c903dac4f6aceb132"].pack("H*")}
-  let(:client_seal_key) {["6f0d99535033951cbe499cd1914fe9ee"].pack("H*")}
-  let(:server_sign_key) {["f7f97a82ec390f9c903dac4f6aceb132"].pack("H*")}
-  let(:server_seal_key) {["6f0d99535033951cbe499cd1914fe9ee"].pack("H*")}
-
-  describe "#sign_message" do
-
-    it "signs a message and when KEY_EXCHANGE is true" do
-      expect(inst).to receive(:client_sign_key).and_return(client_sign_key)
-      expect(inst).to receive(:client_seal_key).and_return(client_seal_key)
-      expect(inst).to receive(:negotiate_key_exchange?).and_return(true)
-      sm = inst.sign_message("Test Message")
-      str = "01000000b35ccd60c110c52f00000000"
-      expect(sm.unpack("H*")[0]).to eq(str)
-    end
-
-  end
-
-  describe "#verify_signature" do
-
-    it "verifies a message signature" do
-      expect(inst).to receive(:server_sign_key).and_return(server_sign_key)
-      expect(inst).to receive(:server_seal_key).and_return(server_seal_key)
-      expect(inst).to receive(:negotiate_key_exchange?).and_return(true)
-      sig = "01000000b35ccd60c110c52f00000000"
-      sm = inst.verify_signature([sig].pack("H*"), "Test Message")
-      expect(sm).to be true
-    end
-
-  end
-
-  describe "#seal_message" do
-    it "should seal the message" do
-      expect(inst).to receive(:client_seal_key).and_return(client_seal_key)
-      emsg = inst.seal_message("rubyntlm")
-      expect(emsg.unpack("H*")[0]).to eq("d7389b9604f6274f")
-    end
-  end
-
-  describe "#unseal_message" do
-    it "should unseal the message" do
-      expect(inst).to receive(:server_seal_key).and_return(server_seal_key)
-      msg = inst.unseal_message(["d7389b9604f6274f"].pack("H*"))
-      expect(msg).to eq("rubyntlm")
-    end
-  end
-
-  describe "#exported_session_key" do
-    it "returns a random 16-byte key when negotiate_key_exchange? is true" do
-      expect(inst).to receive(:negotiate_key_exchange?).and_return(true)
-      expect(inst).not_to receive(:user_session_key)
-      inst.exported_session_key
-    end
-
-    it "returns the user_session_key when negotiate_key_exchange? is false" do
-      expect(inst).to receive(:negotiate_key_exchange?).and_return(false)
-      expect(inst).to receive(:user_session_key).and_return(user_session_key)
-      inst.exported_session_key
-    end
-  end
-
-end
+require 'spec_helper'
+
+describe Net::NTLM::Client::Session do
+  let(:t2_challenge) { Net::NTLM::Message.decode64 "TlRMTVNTUAACAAAADAAMADgAAAA1goriAAyk1DmJUnUAAAAAAAAAAFAAUABEAAAABgLwIwAAAA9TAEUAUgBWAEUAUgACAAwAUwBFAFIAVgBFAFIAAQAMAFMARQBSAFYARQBSAAQADABzAGUAcgB2AGUAcgADAAwAcwBlAHIAdgBlAHIABwAIADd7mrNaB9ABAAAAAA==" }
+  let(:inst) { Net::NTLM::Client::Session.new(nil, t2_challenge) }
+  let(:user_session_key) {["3c4918ff0b33e2603e5d7ceaf34bb7d5"].pack("H*")}
+  let(:client_sign_key) {["f7f97a82ec390f9c903dac4f6aceb132"].pack("H*")}
+  let(:client_seal_key) {["6f0d99535033951cbe499cd1914fe9ee"].pack("H*")}
+  let(:server_sign_key) {["f7f97a82ec390f9c903dac4f6aceb132"].pack("H*")}
+  let(:server_seal_key) {["6f0d99535033951cbe499cd1914fe9ee"].pack("H*")}
+
+  describe "#sign_message" do
+
+    it "signs a message and when KEY_EXCHANGE is true" do
+      expect(inst).to receive(:client_sign_key).and_return(client_sign_key)
+      expect(inst).to receive(:client_seal_key).and_return(client_seal_key)
+      expect(inst).to receive(:negotiate_key_exchange?).and_return(true)
+      sm = inst.sign_message("Test Message")
+      str = "01000000b35ccd60c110c52f00000000"
+      expect(sm.unpack("H*")[0]).to eq(str)
+    end
+
+  end
+
+  describe "#verify_signature" do
+
+    it "verifies a message signature" do
+      expect(inst).to receive(:server_sign_key).and_return(server_sign_key)
+      expect(inst).to receive(:server_seal_key).and_return(server_seal_key)
+      expect(inst).to receive(:negotiate_key_exchange?).and_return(true)
+      sig = "01000000b35ccd60c110c52f00000000"
+      sm = inst.verify_signature([sig].pack("H*"), "Test Message")
+      expect(sm).to be true
+    end
+
+  end
+
+  describe "#seal_message" do
+    it "should seal the message" do
+      expect(inst).to receive(:client_seal_key).and_return(client_seal_key)
+      emsg = inst.seal_message("rubyntlm")
+      expect(emsg.unpack("H*")[0]).to eq("d7389b9604f6274f")
+    end
+  end
+
+  describe "#unseal_message" do
+    it "should unseal the message" do
+      expect(inst).to receive(:server_seal_key).and_return(server_seal_key)
+      msg = inst.unseal_message(["d7389b9604f6274f"].pack("H*"))
+      expect(msg).to eq("rubyntlm")
+    end
+  end
+
+  describe "#exported_session_key" do
+    it "returns a random 16-byte key when negotiate_key_exchange? is true" do
+      expect(inst).to receive(:negotiate_key_exchange?).and_return(true)
+      expect(inst).not_to receive(:user_session_key)
+      inst.exported_session_key
+    end
+
+    it "returns the user_session_key when negotiate_key_exchange? is false" do
+      expect(inst).to receive(:negotiate_key_exchange?).and_return(false)
+      expect(inst).to receive(:user_session_key).and_return(user_session_key)
+      inst.exported_session_key
+    end
+  end
+
+end

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

@@ -1,64 +1,64 @@
-require 'spec_helper'
-
-describe Net::NTLM::Client do
-  let(:inst) { Net::NTLM::Client.new("test", "test01", :workstation => "testhost") }
-  let(:user_session_key) {["3c4918ff0b33e2603e5d7ceaf34bb7d5"].pack("H*")}
-
-  describe "#init_context" do
-
-    it "returns a default Type1 message" do
-      t1 = inst.init_context
-      expect(t1).to be_instance_of Net::NTLM::Message::Type1
-      expect(t1.domain).to eq("")
-      expect(t1.workstation).to eq("testhost")
-      expect(t1).to have_flag(:UNICODE)
-      expect(t1).to have_flag(:OEM)
-      expect(t1).to have_flag(:SIGN)
-      expect(t1).to have_flag(:SEAL)
-      expect(t1).to have_flag(:REQUEST_TARGET)
-      expect(t1).to have_flag(:NTLM)
-      expect(t1).to have_flag(:ALWAYS_SIGN)
-      expect(t1).to have_flag(:NTLM2_KEY)
-      expect(t1).to have_flag(:KEY128)
-      expect(t1).to have_flag(:KEY_EXCHANGE)
-      expect(t1).to have_flag(:KEY56)
-    end
-
-    it "clears session variable on new init_context" do
-      inst.instance_variable_set :@session, "BADSESSION"
-      expect(inst.session).to eq("BADSESSION")
-      inst.init_context
-      expect(inst.session).to be_nil
-    end
-
-    it "returns a Type1 message with custom flags" do
-      flags = Net::NTLM::FLAGS[:UNICODE] | Net::NTLM::FLAGS[:REQUEST_TARGET] | Net::NTLM::FLAGS[:NTLM]
-      inst = Net::NTLM::Client.new("test", "test01", :workstation => "testhost", :flags => flags)
-      t1 = inst.init_context
-      expect(t1).to be_instance_of Net::NTLM::Message::Type1
-      expect(t1.domain).to eq("")
-      expect(t1.workstation).to eq("testhost")
-      expect(t1).to have_flag(:UNICODE)
-      expect(t1).not_to have_flag(:OEM)
-      expect(t1).not_to have_flag(:SIGN)
-      expect(t1).not_to have_flag(:SEAL)
-      expect(t1).to have_flag(:REQUEST_TARGET)
-      expect(t1).to have_flag(:NTLM)
-      expect(t1).not_to have_flag(:ALWAYS_SIGN)
-      expect(t1).not_to have_flag(:NTLM2_KEY)
-      expect(t1).not_to have_flag(:KEY128)
-      expect(t1).not_to have_flag(:KEY_EXCHANGE)
-      expect(t1).not_to have_flag(:KEY56)
-    end
-
-    it "calls authenticate! when we receive a Challenge Message" do
-      t2_challenge = "TlRMTVNTUAACAAAADAAMADgAAAA1goriAAyk1DmJUnUAAAAAAAAAAFAAUABEAAAABgLwIwAAAA9TAEUAUgBWAEUAUgACAAwAUwBFAFIAVgBFAFIAAQAMAFMARQBSAFYARQBSAAQADABzAGUAcgB2AGUAcgADAAwAcwBlAHIAdgBlAHIABwAIADd7mrNaB9ABAAAAAA=="
-      session = double("session")
-      expect(session).to receive(:authenticate!)
-      expect(Net::NTLM::Client::Session).to receive(:new).with(inst, instance_of(Net::NTLM::Message::Type2)).and_return(session)
-      inst.init_context t2_challenge
-    end
-
-  end
-
-end
+require 'spec_helper'
+
+describe Net::NTLM::Client do
+  let(:inst) { Net::NTLM::Client.new("test", "test01", :workstation => "testhost") }
+  let(:user_session_key) {["3c4918ff0b33e2603e5d7ceaf34bb7d5"].pack("H*")}
+
+  describe "#init_context" do
+
+    it "returns a default Type1 message" do
+      t1 = inst.init_context
+      expect(t1).to be_instance_of Net::NTLM::Message::Type1
+      expect(t1.domain).to eq("")
+      expect(t1.workstation).to eq("testhost")
+      expect(t1).to have_flag(:UNICODE)
+      expect(t1).to have_flag(:OEM)
+      expect(t1).to have_flag(:SIGN)
+      expect(t1).to have_flag(:SEAL)
+      expect(t1).to have_flag(:REQUEST_TARGET)
+      expect(t1).to have_flag(:NTLM)
+      expect(t1).to have_flag(:ALWAYS_SIGN)
+      expect(t1).to have_flag(:NTLM2_KEY)
+      expect(t1).to have_flag(:KEY128)
+      expect(t1).to have_flag(:KEY_EXCHANGE)
+      expect(t1).to have_flag(:KEY56)
+    end
+
+    it "clears session variable on new init_context" do
+      inst.instance_variable_set :@session, "BADSESSION"
+      expect(inst.session).to eq("BADSESSION")
+      inst.init_context
+      expect(inst.session).to be_nil
+    end
+
+    it "returns a Type1 message with custom flags" do
+      flags = Net::NTLM::FLAGS[:UNICODE] | Net::NTLM::FLAGS[:REQUEST_TARGET] | Net::NTLM::FLAGS[:NTLM]
+      inst = Net::NTLM::Client.new("test", "test01", :workstation => "testhost", :flags => flags)
+      t1 = inst.init_context
+      expect(t1).to be_instance_of Net::NTLM::Message::Type1
+      expect(t1.domain).to eq("")
+      expect(t1.workstation).to eq("testhost")
+      expect(t1).to have_flag(:UNICODE)
+      expect(t1).not_to have_flag(:OEM)
+      expect(t1).not_to have_flag(:SIGN)
+      expect(t1).not_to have_flag(:SEAL)
+      expect(t1).to have_flag(:REQUEST_TARGET)
+      expect(t1).to have_flag(:NTLM)
+      expect(t1).not_to have_flag(:ALWAYS_SIGN)
+      expect(t1).not_to have_flag(:NTLM2_KEY)
+      expect(t1).not_to have_flag(:KEY128)
+      expect(t1).not_to have_flag(:KEY_EXCHANGE)
+      expect(t1).not_to have_flag(:KEY56)
+    end
+
+    it "calls authenticate! when we receive a Challenge Message" do
+      t2_challenge = "TlRMTVNTUAACAAAADAAMADgAAAA1goriAAyk1DmJUnUAAAAAAAAAAFAAUABEAAAABgLwIwAAAA9TAEUAUgBWAEUAUgACAAwAUwBFAFIAVgBFAFIAAQAMAFMARQBSAFYARQBSAAQADABzAGUAcgB2AGUAcgADAAwAcwBlAHIAdgBlAHIABwAIADd7mrNaB9ABAAAAAA=="
+      session = double("session")
+      expect(session).to receive(:authenticate!)
+      expect(Net::NTLM::Client::Session).to receive(:new).with(inst, instance_of(Net::NTLM::Message::Type2), nil).and_return(session)
+      inst.init_context t2_challenge
+    end
+
+  end
+
+end

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

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

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

@@ -1,33 +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
-      expect(fieldset_object.serialize).to eq('TestFoo')
-    end
-
-    it 'should parse a string across the fields' do
-      fieldset_object.parse('FooBarBaz')
-      expect(fieldset_object.serialize).to eq('FooBarB')
-    end
-
-    it 'should return an aggregate size of all the fields' do
-      expect(fieldset_object.size).to eq(7)
-    end
-  end
-end
+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
+      expect(fieldset_object.serialize).to eq('TestFoo')
+    end
+
+    it 'should parse a string across the fields' do
+      fieldset_object.parse('FooBarBaz')
+      expect(fieldset_object.serialize).to eq('FooBarB')
+    end
+
+    it 'should return an aggregate size of all the fields' do
+      expect(fieldset_object.size).to eq(7)
+    end
+  end
+end