rubyntlm 0.6.1 → 0.6.2

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

@@ -1,17 +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
+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), nil).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'.encode(::Encoding::ASCII_8BIT).freeze)).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".freeze)).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'.encode(::Encoding::ASCII_8BIT).freeze)).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".freeze)).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

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

@@ -1,34 +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
-      expect(field_without_size.size).to eq(0)
-    end
-
-    it 'should return 0 if active but no size specified' do
-      field_without_size.active = true
-      expect(field_without_size.size).to eq(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
-      expect(field_with_size.size).to eq(100)
-    end
-
-    it 'should still return 0 if not active' do
-      field_with_size.active = false
-      expect(field_with_size.size).to eq(0)
-    end
-  end
-
-
-
-end
+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
+      expect(field_without_size.size).to eq(0)
+    end
+
+    it 'should return 0 if active but no size specified' do
+      field_without_size.active = true
+      expect(field_without_size.size).to eq(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
+      expect(field_with_size.size).to eq(100)
+    end
+
+    it 'should still return 0 if not active' do
+      field_with_size.active = false
+      expect(field_with_size.size).to eq(0)
+    end
+  end
+
+
+
+end