rubyntlm 0.4.0 → 0.5.0

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

@@ -4,13 +4,13 @@ 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"
+      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
-      Net::NTLM::EncodeUtil.decode_utf16le("T\x00e\x00s\x00t\x00").should == 'Test'
+      expect(Net::NTLM::EncodeUtil.decode_utf16le("T\x00e\x00s\x00t\x00")).to eq('Test')
     end
   end
-end
+end

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

@@ -18,16 +18,16 @@ describe Net::NTLM::FieldSet do
     end
 
     it 'should serialize all the fields' do
-      fieldset_object.serialize.should == 'TestFoo'
+      expect(fieldset_object.serialize).to eq('TestFoo')
     end
 
     it 'should parse a string across the fields' do
       fieldset_object.parse('FooBarBaz')
-      fieldset_object.serialize.should == 'FooBarB'
+      expect(fieldset_object.serialize).to eq('FooBarB')
     end
 
     it 'should return an aggregate size of all the fields' do
-      fieldset_object.size.should == 7
+      expect(fieldset_object.size).to eq(7)
     end
   end
-end
+end

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

@@ -7,12 +7,12 @@ describe Net::NTLM::Field do
   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
+      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
-      field_without_size.size.should == 0
+      expect(field_without_size.size).to eq(0)
     end
   end
 
@@ -20,15 +20,15 @@ describe Net::NTLM::Field 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
+      expect(field_with_size.size).to eq(100)
     end
 
     it 'should still return 0 if not active' do
       field_with_size.active = false
-      field_with_size.size.should == 0
+      expect(field_with_size.size).to eq(0)
     end
   end
 
 
 
-end
+end

data/spec/lib/net/ntlm/message/type1_spec.rb

@@ -7,7 +7,7 @@ describe Net::NTLM::Message::Type1 do
       { :name => :flag, :class => Net::NTLM::Int32LE, :value =>  Net::NTLM::DEFAULT_FLAGS[:TYPE1], :active => true },
       { :name => :domain, :class => Net::NTLM::SecurityBuffer, :value => '', :active => true },
       { :name => :workstation, :class => Net::NTLM::SecurityBuffer, :value =>  Socket.gethostname, :active => true },
-      { :name => :padding, :class => Net::NTLM::String, :value => '', :active => false },
+      { :name => :os_version, :class => Net::NTLM::String, :value => '', :active => false },
   ]
   flags = [
       :UNICODE,
@@ -24,19 +24,108 @@ 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 == ''
+    expect(t1.class).to eq(Net::NTLM::Message::Type1)
+    expect(t1.domain).to eq('')
+    expect(t1.flag).to eq(557575)
+    expect(t1.os_version).to eq('')
+    expect(t1.sign).to eq("NTLMSSP\0")
+    expect(t1.type).to eq(1)
+    expect(t1.workstation).to eq('')
   end
 
   it 'should serialize' do
     t1 = Net::NTLM::Message::Type1.new
     t1.workstation = ''
-    t1.encode64.should == type1_packet
+    expect(t1.encode64).to eq(type1_packet)
   end
 
-end
+  describe '.parse' do
+    subject(:message) { described_class.parse(data) }
+    # http://davenport.sourceforge.net/ntlm.html#appendixC7
+    context 'NTLM2 Session Response Authentication; NTLM2 Signing and Sealing Using the 128-bit NTLM2 Session Response User Session Key With Key Exchange Negotiated' do
+      let(:data) do
+        ['4e544c4d5353500001000000b78208e000000000000000000000000000000000'].pack('H*')
+      end
+
+      it 'should set the magic' do
+        expect(message.sign).to eql(Net::NTLM::SSP_SIGN)
+      end
+      it 'should set the type' do
+        expect(message.type).to eq(1)
+      end
+      it 'should set the flags' do
+        expect(message.flag).to eq(0xe00882b7)
+        expect(message).to have_flag(:UNICODE)
+        expect(message).to have_flag(:OEM)
+        expect(message).to have_flag(:REQUEST_TARGET)
+        expect(message).to have_flag(:SIGN)
+        expect(message).to have_flag(:SEAL)
+        expect(message).to have_flag(:NTLM)
+        expect(message).to have_flag(:ALWAYS_SIGN)
+        expect(message).to have_flag(:NTLM2_KEY)
+        expect(message).to have_flag(:KEY128)
+        expect(message).to have_flag(:KEY_EXCHANGE)
+        expect(message).to have_flag(:KEY56)
+      end
+      it 'should have empty workstation' do
+        expect(message.workstation).to be_empty
+      end
+      it 'should have empty domain' do
+        expect(message.domain).to be_empty
+      end
+
+    end
+
+    # http://davenport.sourceforge.net/ntlm.html#appendixC9
+    context 'NTLMv2 Authentication; NTLM1 Signing and Sealing Using the 40-bit NTLMv2 User Session Key' do
+      let(:data) { ['4e544c4d53535000010000003782000000000000000000000000000000000000'].pack('H*') }
+
+      it 'should set the magic' do
+        expect(message.sign).to eql(Net::NTLM::SSP_SIGN)
+      end
+      it 'should set the type' do
+        expect(message.type).to eq(1)
+      end
+      it 'should set the flags' do
+        expect(message.flag).to eq(0x00008237)
+        expect(message).to have_flag(:UNICODE)
+        expect(message).to have_flag(:OEM)
+        expect(message).to have_flag(:REQUEST_TARGET)
+        expect(message).to have_flag(:SIGN)
+        expect(message).to have_flag(:SEAL)
+        expect(message).to have_flag(:NTLM)
+        expect(message).to have_flag(:ALWAYS_SIGN)
+      end
+      it 'should have empty workstation' do
+        expect(message.workstation).to be_empty
+      end
+      it 'should have empty domain' do
+        expect(message.domain).to be_empty
+      end
+    end
+
+    context 'NTLMv2 with OS version' do
+      let(:data) { ['4e544c4d5353500001000000978208e2000000000000000000000000000000000602f0230000000f'].pack('H*') }
+
+      it 'should set the magic' do
+        expect(message.sign).to eql(Net::NTLM::SSP_SIGN)
+      end
+      it 'should set the type' do
+        expect(message.type).to eq(1)
+      end
+      it 'should have empty workstation' do
+        expect(message.workstation).to be_empty
+      end
+      it 'should have empty domain' do
+        expect(message.domain).to be_empty
+      end
+
+      it 'should set OS version info' do
+        expect(message.os_version).to eq(['0602f0230000000f'].pack('H*'))
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/net/ntlm/message/type2_spec.rb

@@ -11,7 +11,7 @@ describe Net::NTLM::Message::Type2 do
       { :name => :flag, :class => Net::NTLM::Int32LE, :value =>  Net::NTLM::DEFAULT_FLAGS[:TYPE2], :active => true },
       { :name => :target_name, :class => Net::NTLM::SecurityBuffer, :value => '', :active => true },
       { :name => :target_info, :class => Net::NTLM::SecurityBuffer, :value =>  '', :active => false },
-      { :name => :padding, :class => Net::NTLM::String, :value => '', :active => false },
+      { :name => :os_version, :class => Net::NTLM::String, :value => '', :active => false },
   ]
   flags = [
       :UNICODE
@@ -24,24 +24,22 @@ 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
-    if "".respond_to?(:force_encoding)
-      t2.padding.should == ("\x06\x01\xB1\x1D\0\0\0\x0F".force_encoding('ASCII-8BIT'))
-    end
-    t2.sign.should == "NTLMSSP\0"
+    expect(t2.class).to eq(Net::NTLM::Message::Type2)
+    expect(t2.challenge).to eq(14872292244261496103)
+    expect(t2.context).to eq(0)
+    expect(t2.flag).to eq(42631685)
+    expect(t2.os_version).to eq(['0601b11d0000000f'].pack('H*'))
+    expect(t2.sign).to eq("NTLMSSP\0")
 
     t2_target_info = Net::NTLM::EncodeUtil.decode_utf16le(t2.target_info)
     if RUBY_VERSION == "1.8.7"
-      t2_target_info.should == "\x02\x1CVAGRANT-2008R2\x01\x1CVAGRANT-2008R2\x04\x1Cvagrant-2008R2\x03\x1Cvagrant-2008R2\a\b\e$(D+&\e(B\0\0"
+      expect(t2_target_info).to eq("\x02\x1CVAGRANT-2008R2\x01\x1CVAGRANT-2008R2\x04\x1Cvagrant-2008R2\x03\x1Cvagrant-2008R2\a\b\e$(D+&\e(B\0\0")
     else
-      t2_target_info.should == "\u0002\u001CVAGRANT-2008R2\u0001\u001CVAGRANT-2008R2\u0004\u001Cvagrant-2008R2\u0003\u001Cvagrant-2008R2\a\b፤ᐝ❴ǎ\0\0"
+      expect(t2_target_info).to eq("\u0002\u001CVAGRANT-2008R2\u0001\u001CVAGRANT-2008R2\u0004\u001Cvagrant-2008R2\u0003\u001Cvagrant-2008R2\a\b፤ᐝ❴ǎ\0\0")
     end
 
-    Net::NTLM::EncodeUtil.decode_utf16le(t2.target_name).should == "VAGRANT-2008R2"
-    t2.type.should == 2
+    expect(Net::NTLM::EncodeUtil.decode_utf16le(t2.target_name)).to eq("VAGRANT-2008R2")
+    expect(t2.type).to eq(2)
   end
 
   it 'should serialize' do
@@ -51,16 +49,16 @@ describe Net::NTLM::Message::Type2 do
     t2.challenge = source.challenge
     t2.context = source.context
     t2.flag = source.flag
-    t2.padding = source.padding
+    t2.os_version = source.os_version
     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.enable(:os_version)
 
-    t2.encode64.should == type2_packet
+    expect(t2.encode64).to eq(type2_packet)
   end
 
   it 'should generate a type 3 response' do
@@ -72,17 +70,63 @@ describe Net::NTLM::Message::Type2 do
     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 == ''
+    expect(t3.domain).to eq(type3_known.domain)
+    expect(t3.flag).to eq(type3_known.flag)
+    expect(t3.sign).to eq("NTLMSSP\0")
+    expect(t3.workstation).to eq("k\0o\0b\0e\0.\0l\0o\0c\0a\0l\0")
+    expect(t3.user).to eq("v\0a\0g\0r\0a\0n\0t\0")
+    expect(t3.session_key).to eq('')
   end
 
   it 'should upcase domain when provided' do
     t2 = Net::NTLM::Message.decode64(type2_packet)
     t3 = t2.response({:user => 'vagrant', :password => 'vagrant', :domain => 'domain'}, {:ntlmv2 => true, :workstation => 'kobe.local'})
-    t3.domain.should == "D\0O\0M\0A\0I\0N\0"
+    expect(t3.domain).to eq("D\0O\0M\0A\0I\0N\0")
   end
-end
+
+  describe '.parse' do
+    subject(:message) { described_class.parse(data) }
+    # http://davenport.sourceforge.net/ntlm.html#appendixC7
+    context 'NTLM2 Session Response Authentication; NTLM2 Signing and Sealing Using the 128-bit NTLM2 Session Response User Session Key With Key Exchange Negotiated' do
+      let(:data) do
+        [
+          '4e544c4d53535000020000000c000c0030000000358289e0677f1c557a5ee96c' \
+          '0000000000000000460046003c00000054004500530054004e00540002000c00' \
+          '54004500530054004e00540001000c004d0045004d0042004500520003001e00' \
+          '6d0065006d006200650072002e0074006500730074002e0063006f006d000000' \
+          '0000'
+        ].pack('H*')
+      end
+
+      it 'should set the magic' do
+        expect(message.sign).to eql(Net::NTLM::SSP_SIGN)
+      end
+      it 'should set the type' do
+        expect(message.type).to eq(2)
+      end
+      it 'should set the target name' do
+        # TESTNT
+        expect(message.target_name).to eq(["54004500530054004e005400"].pack('H*'))
+      end
+      it 'should set the flags' do
+        expect(message.flag).to eq(0xe0898235)
+      end
+      it 'should set the challenge' do
+        expect(message.challenge).to eq(0x6ce95e7a551c7f67)
+      end
+      it 'should set an empty context' do
+        expect(message.context).to be_zero
+      end
+      it 'should set target info' do
+        ti = [
+          '02000c0054004500530054004e00540001000c004d0045004d00420045005200' \
+          '03001e006d0065006d006200650072002e0074006500730074002e0063006f00' \
+          '6d0000000000'
+        ].pack('H*')
+        expect(message.target_info).to eq(ti)
+      end
+
+    end
+  end
+
+end

data/spec/lib/net/ntlm/message/type3_spec.rb

@@ -5,16 +5,221 @@ describe Net::NTLM::Message::Type3 do
   fields = [
       { :name => :sign, :class => Net::NTLM::String, :value => Net::NTLM::SSP_SIGN, :active => true },
       { :name => :type, :class => Net::NTLM::Int32LE, :value => 3, :active => true },
-      { :name => :flag, :class => Net::NTLM::Int64LE, :value =>  0, :active => false },
       { :name => :lm_response, :class => Net::NTLM::SecurityBuffer, :value => '', :active => true },
       { :name => :ntlm_response, :class => Net::NTLM::SecurityBuffer, :value =>  '', :active => true },
       { :name => :domain, :class => Net::NTLM::SecurityBuffer, :value =>  '', :active => true },
       { :name => :user, :class => Net::NTLM::SecurityBuffer, :value =>  '', :active => true },
       { :name => :workstation, :class => Net::NTLM::SecurityBuffer, :value =>  '', :active => true },
       { :name => :session_key, :class => Net::NTLM::SecurityBuffer, :value =>  '', :active => false },
+      { :name => :flag, :class => Net::NTLM::Int32LE, :value =>  0, :active => false },
   ]
   flags = []
   it_behaves_like 'a fieldset', fields
   it_behaves_like 'a message', flags
 
-end
+  describe '.parse' do
+    subject(:message) { described_class.parse(data) }
+
+    context 'with NTLMv2 data' do
+      let(:data) do
+        # Captured NTLMSSP blob from smbclient with username 'administrator'
+        # and a blank password, i.e.:
+        #   smbclient -U 'administrator%' -L //192.168.100.140/
+        [
+          '4e544c4d53535000030000001800180040000000c400c4005800000012001200' \
+          '1c0100001a001a002e0100001a001a0048010000100010006201000015820860' \
+          'ced203d860b80c7350050754b238202a8c1c63134f0ae0f086a3fb147e8b2f9f' \
+          'de3ef1b1b43c83dc010100000000000080512dba020ed0011c5bc2c8339fd29a' \
+          '0000000002001e00570049004e002d00420035004a004e003300520048004700' \
+          '46003300310001001e00570049004e002d00420035004a004e00330052004800' \
+          '470046003300310004001e00570049004e002d00420035004a004e0033005200' \
+          '4800470046003300310003001e00570049004e002d00420035004a004e003300' \
+          '52004800470046003300310007000800a209e5ba020ed0010000000057004f00' \
+          '52004b00470052004f0055005000610064006d0069006e006900730074007200' \
+          '610074006f0072004100550053002d004c004500450054002d00310030003300' \
+          '31007036615cd6d9b19a685ded4312311cd7'
+        ].pack('H*')
+      end
+
+      let(:server_challenge) { ['f588469dc96fe809'].pack('H*') }
+
+      it 'should set the magic' do
+        expect(message.sign).to eql(Net::NTLM::SSP_SIGN)
+      end
+      it 'should set the type' do
+        expect(message.type).to eq(3)
+      end
+      it 'should set the LM response' do
+        lm_response = ['ced203d860b80c7350050754b238202a8c1c63134f0ae0f0'].pack('H*')
+        expect(message.lm_response).to eq(lm_response)
+      end
+      it 'should set the NTLM response' do
+        ntlm_response = [
+          '86a3fb147e8b2f9fde3ef1b1b43c83dc010100000000000080512dba020ed001' \
+          '1c5bc2c8339fd29a0000000002001e00570049004e002d00420035004a004e00' \
+          '330052004800470046003300310001001e00570049004e002d00420035004a00' \
+          '4e00330052004800470046003300310004001e00570049004e002d0042003500' \
+          '4a004e00330052004800470046003300310003001e00570049004e002d004200' \
+          '35004a004e00330052004800470046003300310007000800a209e5ba020ed001' \
+          '00000000'
+        ].pack('H*')
+        expect(message.ntlm_response).to eq(ntlm_response)
+      end
+      it 'should set the user' do
+        # administrator
+        user = ['610064006d0069006e006900730074007200610074006f007200'].pack('H*')
+        expect(message.user).to eq(user)
+      end
+      it 'should set the domain' do
+        # WORKGROUP
+        domain = ['57004f0052004b00470052004f0055005000'].pack('H*')
+        expect(message.domain).to eq(domain)
+      end
+      it 'should set the workstation' do
+        # AUS-LEET-1031
+        workstation = ['4100550053002d004c004500450054002d003100300033003100'].pack('H*')
+        expect(message.workstation).to eq(workstation)
+      end
+      it 'should set the session key' do
+        session_key = ['7036615cd6d9b19a685ded4312311cd7'].pack('H*')
+        expect(message.session_key).to eq(session_key)
+      end
+
+      it 'should set the flags' do
+        expect(message.flag).to eq(0x60088215)
+      end
+
+      it 'should NOT set the OS version structure' do
+        expect(message.os_version).to be_nil
+      end
+
+      describe '#blank_password?' do
+        it 'should be true' do
+          expect(message.blank_password?(server_challenge)).to be true
+        end
+      end
+
+      describe '#ntlm_version' do
+        let(:ver) { message.ntlm_version }
+        it 'should be :ntlmv2' do
+          expect(ver).to eq(:ntlmv2)
+        end
+      end
+
+    end
+
+    # http://davenport.sourceforge.net/ntlm.html#appendixC7
+    context 'NTLM2 Session Response Authentication; NTLM2 Signing and Sealing Using the 128-bit NTLM2 Session Response User Session Key With Key Exchange Negotiated' do
+
+      let(:data) do
+        [
+          '4e544c4d5353500003000000180018006000000018001800780000000c000c00' \
+          '40000000080008004c0000000c000c00540000001000100090000000358288e0' \
+          '54004500530054004e00540074006500730074004d0045004d00420045005200' \
+          '404d1b6f6915258000000000000000000000000000000000ea8cc49f24da157f' \
+          '13436637f77693d8b992d619e584c7ee727a5240822ec7af4e9100c43e6fee7f'
+        ].pack('H*')
+      end
+
+      it 'should set the LM response' do
+        lm_response = ['404d1b6f6915258000000000000000000000000000000000'].pack('H*')
+        expect(message.lm_response).to eq(lm_response)
+      end
+      it 'should set the NTLM response' do
+        ntlm_response = [ 'ea8cc49f24da157f13436637f77693d8b992d619e584c7ee' ].pack('H*')
+        expect(message.ntlm_response).to eq(ntlm_response)
+      end
+      it 'should set the domain' do
+        # TESTNT
+        domain = ['54004500530054004e005400'].pack('H*')
+        expect(message.domain).to eq(domain)
+      end
+      it 'should set the user' do
+        # test
+        user = ['7400650073007400'].pack('H*')
+        expect(message.user).to eq(user)
+      end
+      it 'should set the workstation' do
+        # MEMBER
+        workstation = ['4d0045004d00420045005200'].pack('H*')
+        expect(message.workstation).to eq(workstation)
+      end
+      it 'should set the session key' do
+        session_key = ['727a5240822ec7af4e9100c43e6fee7f'].pack('H*')
+        expect(message.session_key).to eq(session_key)
+      end
+
+      let(:server_challenge) { ['677f1c557a5ee96c'].pack('H*') }
+      describe '#password?' do
+        it 'should be true for "test1234"' do
+          expect(message.password?('test1234', server_challenge)).to be true
+        end
+      end
+      describe '#blank_password?' do
+        it 'should be false' do
+          expect(message.blank_password?(server_challenge)).to be false
+        end
+      end
+
+      describe '#ntlm_version' do
+        let(:ver) { message.ntlm_version }
+        it 'should be :ntlm2_session' do
+          expect(ver).to eq(:ntlm2_session)
+        end
+      end
+
+    end
+
+    # http://davenport.sourceforge.net/ntlm.html#appendixC9
+    context 'NTLMv2 Authentication; NTLM1 Signing and Sealing Using the 40-bit NTLMv2 User Session Key' do
+      let(:data) do
+        [
+          '4e544c4d5353500003000000180018006000000076007600780000000c000c00' \
+          '40000000080008004c0000000c000c005400000000000000ee00000035828000' \
+          '54004500530054004e00540074006500730074004d0045004d00420045005200' \
+          '5d55a02b60a40526ac9a1e4d15fa45a0f2e6329726c598e8f77c67dad00b9321' \
+          '6242b197fe6addfa0101000000000000502db638677bc301f2e6329726c598e8' \
+          '0000000002000c0054004500530054004e00540001000c004d0045004d004200' \
+          '4500520003001e006d0065006d006200650072002e0074006500730074002e00' \
+          '63006f006d000000000000000000'
+        ].pack 'H*'
+      end
+
+      it 'should set the NTLM response' do
+        ntlm_response = [
+          'f77c67dad00b93216242b197fe6addfa0101000000000000502db638677bc301' \
+          'f2e6329726c598e80000000002000c0054004500530054004e00540001000c00' \
+          '4d0045004d0042004500520003001e006d0065006d006200650072002e007400' \
+          '6500730074002e0063006f006d000000000000000000'
+        ].pack 'H*'
+        expect(message.ntlm_response).to eq(ntlm_response)
+      end
+
+      it 'should set the domain' do
+        # TESTNT
+        domain = ['54004500530054004e005400'].pack('H*')
+        expect(message.domain).to eq(domain)
+      end
+      it 'should set the user' do
+        # test
+        user = ['7400650073007400'].pack('H*')
+        expect(message.user).to eq(user)
+      end
+      it 'should set the workstation' do
+        # MEMBER
+        workstation = ['4d0045004d00420045005200'].pack('H*')
+        expect(message.workstation).to eq(workstation)
+      end
+
+      describe '#ntlm_version' do
+        let(:ver) { message.ntlm_version }
+        it 'should be :ntlmv2' do
+          expect(ver).to eq(:ntlmv2)
+        end
+      end
+
+    end
+
+  end
+
+end