rubyntlm 0.6.6 → 0.6.7

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

@@ -1,26 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../../../lib/net/ntlm/version")
-
-RSpec.describe Net::NTLM::VERSION do
-
-  it 'should contain an integer value for Major Version' do
-    expect(Net::NTLM::VERSION::MAJOR).to be_an Integer
-  end
-
-  it 'should contain an integer value for Minor Version' do
-    expect(Net::NTLM::VERSION::MINOR).to be_an Integer
-  end
-
-  it 'should contain an integer value for Patch Version' do
-    expect(Net::NTLM::VERSION::TINY).to be_an Integer
-  end
-
-  it 'should contain an aggregate version string' do
-    string = [
-        Net::NTLM::VERSION::MAJOR,
-        Net::NTLM::VERSION::MINOR,
-        Net::NTLM::VERSION::TINY
-    ].join('.')
-    expect(Net::NTLM::VERSION::STRING).to be_a String
-    expect(Net::NTLM::VERSION::STRING).to eq(string)
-  end
-end

data/spec/lib/net/ntlm_spec.rb

@@ -1,133 +0,0 @@
-RSpec.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*")}
-  let(:padded_pwd) { passwd.upcase.ljust(14, "\0")}
-  let(:keys) { Net::NTLM.gen_keys(padded_pwd)}
-
-  it 'should convert a value to 64-bit LE Integer' do
-    expect(Net::NTLM.pack_int64le(42)).to eq("\x2A\x00\x00\x00\x00\x00\x00\x00")
-  end
-
-  it 'should split a string into an array of slices, 7 chars or less' do
-    expect(Net::NTLM.split7("HelloWorld!")).to eq([ 'HelloWo', 'rld!'])
-  end
-
-  it 'should generate DES keys from the supplied string' do
-    first_key = ["52a2516b252a5161"].pack('H*')
-    second_key = ["3180010101010101"].pack('H*')
-    expect(Net::NTLM.gen_keys(padded_pwd)).to eq([first_key, second_key])
-  end
-
-  it 'should encrypt the string with DES for each key supplied' do
-    first_crypt = ["ff3750bcc2b22412"].pack('H*')
-    second_crypt = ["c2265b23734e0dac"].pack('H*')
-    expect(Net::NTLM::apply_des(Net::NTLM::LM_MAGIC, keys)).to eq([first_crypt, second_crypt])
-  end
-
-  it 'should generate an lm_hash' do
-    expect(Net::NTLM::lm_hash(passwd)).to eq(["ff3750bcc2b22412c2265b23734e0dac"].pack("H*"))
-  end
-
-  it 'should generate an ntlm_hash' do
-    expect(Net::NTLM::ntlm_hash(passwd)).to eq(["cd06ca7c7e10c99b1d33b7485a2ed808"].pack("H*"))
-  end
-
-  it 'should generate an ntlmv2_hash' do
-    expect(Net::NTLM::ntlmv2_hash(user, passwd, domain)).to eq(["04b8e0ba74289cc540826bab1dee63ae"].pack("H*"))
-  end
-
-  context 'when a user passes an NTLM hash for pass-the-hash' do
-    let(:passwd) { Net::NTLM::EncodeUtil.encode_utf16le('ff3750bcc2b22412c2265b23734e0dac:cd06ca7c7e10c99b1d33b7485a2ed808') }
-
-    it 'should return the correct ntlmv2 hash' do
-      expect(Net::NTLM::ntlmv2_hash(user, passwd, domain)).to eq(["04b8e0ba74289cc540826bab1dee63ae"].pack("H*"))
-    end
-  end
-
-  context 'when the username contains non-ASCI characters' do
-    let(:user) { 'юзер' }
-
-    it 'should return the correct ntlmv2 hash' do
-      expect(Net::NTLM::ntlmv2_hash(user, passwd, domain, { unicode: true })).to eq(["a0f4b914a37faeaee884b6b04a20faf0"].pack("H*"))
-    end
-  end
-
-  it 'should generate an lm_response' do
-    expect(Net::NTLM::lm_response(
-        {
-            :lm_hash => Net::NTLM::lm_hash(passwd),
-            :challenge => challenge
-        }
-    )).to eq(["c337cd5cbd44fc9782a667af6d427c6de67c20c2d3e77c56"].pack("H*"))
-  end
-
-  it 'should generate an ntlm_response' do
-    ntlm_hash = Net::NTLM::ntlm_hash(passwd)
-    expect(Net::NTLM::ntlm_response(
-        {
-            :ntlm_hash => ntlm_hash,
-            :challenge => challenge
-        }
-    )).to eq(["25a98c1c31e81847466b29b2df4680f39958fb8c213a9cc6"].pack("H*"))
-  end
-
-  it 'should generate a lvm2_response' do
-    expect(Net::NTLM::lmv2_response(
-        {
-            :ntlmv2_hash => Net::NTLM::ntlmv2_hash(user, passwd, domain),
-            :challenge => challenge
-        },
-        { :client_challenge => client_ch }
-    )).to eq(["d6e6152ea25d03b7c6ba6629c2d6aaf0ffffff0011223344"].pack("H*"))
-  end
-
-  it 'should generate a ntlmv2_response' do
-    expect(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
-        }
-    )).to eq([
-        "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 }
-    )
-    expect(session[0]).to eq(["ffffff001122334400000000000000000000000000000000"].pack("H*"))
-    expect(session[1]).to eq(["10d550832d12b2ccb79d5ad1f4eed3df82aca4c3681dd455"].pack("H*"))
-  end
-end

data/spec/spec_helper.rb

@@ -1,51 +0,0 @@
-# Coverage must be started before the library under test is loaded, otherwise
-# methods defined at require time are not tracked.
-if ENV['COVERAGE']
-  require 'simplecov'
-
-  SimpleCov.start do
-    add_filter '/spec/'
-    add_filter '/vendor/'
-    enable_coverage :branch if respond_to?(:enable_coverage)
-  end
-end
-
-require 'rspec'
-require 'net/ntlm'
-
-# Custom matchers, shared examples and other support code.
-Dir[File.expand_path('support/**/*.rb', __dir__)].sort.each { |path| require path }
-
-RSpec.configure do |config|
-  # Require `RSpec.describe` rather than a top-level `describe`, so the gem's
-  # specs do not depend on RSpec monkey-patching Object.
-  config.disable_monkey_patching!
-
-  config.expect_with :rspec do |expectations|
-    expectations.syntax = :expect
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.syntax = :expect
-    # Fail fast when a partial double stubs a method the real object does not
-    # have, so refactors in lib/ cannot leave specs passing against a fiction.
-    mocks.verify_partial_doubles = true
-  end
-
-  # Shared example groups get their own metadata rather than leaking it into
-  # the host group. This is the RSpec 4 default.
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-
-  # `rspec --only-failures` and `--next-failure`.
-  config.example_status_persistence_file_path = 'spec/examples.txt'
-
-  # Tagging an example `:focus` runs just that example, without needing to pass
-  # a line number. No effect when nothing is tagged.
-  config.filter_run_when_matching :focus
-
-  # Randomise ordering to surface accidental dependencies between examples, and
-  # print the seed so a failure can be reproduced with `--seed`.
-  config.order = :random
-  Kernel.srand config.seed
-end

data/spec/support/certificates/sha_256_hash.pem

@@ -1,19 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDKjCCAhKgAwIBAgIQV0qwsk2MCoxI2Do7IQ6eQzANBgkqhkiG9w0BAQsFADAa
-MRgwFgYDVQQDDA8xOTIuMTY4LjEzNy4xNjEwHhcNMTYwMTI3MjIyMzA5WhcNMTcw
-MTI3MjI0MzA5WjAaMRgwFgYDVQQDDA8xOTIuMTY4LjEzNy4xNjEwggEiMA0GCSqG
-SIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+bGWZQFYjF+bV1WJ1L/MGVNmJR89aJ44Z
-rKI/IXKFdbn5wjQPWng/DcaHR6xtMXQkc22boe58GK/uzl84ofbRa6qtboa5djdZ
-9CGsd4Yf6CnVz4mhKSi+BnLi80ydhIRByxoX5bGcCSW6dixR5XiNMaMKzhCjQ+of
-TU+PBNt7doXB7p0mO4AZz42v4rorRiPNasETj6wlKhFKCMvPLePTwphCgCQsLvgG
-NQKtFD7TXvrZwplPSeCPhnzd1vHoZMisMn8ZVQ5dAfSEGGkPkOLO0htbUbdaNMoU
-DPyo7Bu62Q/dqqo1MNbMYM5Ilw8mxe4drOs9UupH0eMovFhVMO0LAgMBAAGjbDBq
-MA4GA1UdDwEB/wQEAwIFoDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEw
-GgYDVR0RBBMwEYIPMTkyLjE2OC4xMzcuMTYxMB0GA1UdDgQWBBSLuqyHonSmdm8m
-9R+z2obO/X3/+TANBgkqhkiG9w0BAQsFAAOCAQEAH4pDGBclTHrwF+Bkbfj81ibK
-E2SJSHbdhSx6YCsR28jXUOESfaik5ZPPMXscJqVc1FPpsU9clPFnGiAf0Kt48gsR
-twfrRSGgJRv1ZgQyJ4dEQkXbQf2+8uY25Rv4kkFDSvPrE6E9o9Jf9bjqefUYski1
-YoYdWzgrh/2qoNhnM34wizZgE1bWYbWA9MlUuWH9q/OBEx9uP/K53SXOR7DRzYcY
-Kg1Z7hV86nvc0WutjEadgdtvJ7eUlg8vAWZqWo5SIdp69l0OEWUlHiaRsPImS5Hd
-pX3W8n0wHCxBSntDww7U3SHg6DrYf72taBIQW7xFf63S37yLP4CNss68GqPdyQ==
------END CERTIFICATE-----

data/spec/support/shared/examples/net/ntlm/field_shared.rb

@@ -1,25 +0,0 @@
-RSpec.shared_examples_for 'a field' do  | value, active|
-
-  subject do
-    described_class.new({
-        :value  => value,
-        :active => active
-    })
-  end
-
-  it { should respond_to :active }
-  it { should respond_to :value }
-  it { should respond_to :size }
-  it { should respond_to :parse }
-  it { should respond_to :serialize }
-
-
-  it 'should set the value from initialize options' do
-    expect(subject.value).to eq(value)
-  end
-
-  it 'should set active from initialize options' do
-    expect(subject.active).to eq(active)
-  end
-
-end

data/spec/support/shared/examples/net/ntlm/fieldset_shared.rb

@@ -1,239 +0,0 @@
-RSpec.shared_examples_for 'a fieldset' do |fields|
-
-  subject(:fieldset_class) do
-    Class.new(described_class)
-  end
-
-  context 'the class' do
-    it { should respond_to :string }
-    it { should respond_to :int16LE }
-    it { should respond_to :int32LE }
-    it { should respond_to :int64LE }
-    it { should respond_to :security_buffer }
-    it { should respond_to :prototypes }
-    it { should respond_to :names }
-    it { should respond_to :types }
-    it { should respond_to :opts }
-
-    context 'adding a String Field' do
-      before(:each) do
-        fieldset_class.string(:test_string, { :value => 'Test'})
-      end
-
-      it 'should set the prototypes correctly' do
-        expect(fieldset_class.prototypes).to include([:test_string, Net::NTLM::String, {:value=>"Test"}])
-      end
-
-      it 'should set the names correctly' do
-        expect(fieldset_class.names).to include(:test_string)
-      end
-
-      it 'should set the types correctly' do
-        expect(fieldset_class.types).to include(Net::NTLM::String)
-      end
-
-      it 'should set the opts correctly' do
-        expect(fieldset_class.opts).to include({:value => 'Test'})
-      end
-
-      context 'when creating an instance' do
-        let(:fieldset_object) do
-          fieldset_class.new
-        end
-
-        it 'should have the new accessor' do
-          expect(fieldset_object).to respond_to(:test_string)
-        end
-
-        it 'should have the correct default value' do
-          expect(fieldset_object.test_string).to eq('Test')
-        end
-      end
-    end
-
-    context 'adding a Int16LE Field' do
-      before(:each) do
-        fieldset_class.int16LE(:test_int, { :value => 15})
-      end
-
-      it 'should set the prototypes correctly' do
-        expect(fieldset_class.prototypes).to include([:test_int, Net::NTLM::Int16LE, {:value=>15}])
-      end
-
-      it 'should set the names correctly' do
-        expect(fieldset_class.names).to include(:test_int)
-      end
-
-      it 'should set the types correctly' do
-        expect(fieldset_class.types).to include(Net::NTLM::Int16LE)
-      end
-
-      it 'should set the opts correctly' do
-        expect(fieldset_class.opts).to include({:value => 15})
-      end
-
-      context 'when creating an instance' do
-        let(:fieldset_object) do
-          fieldset_class.new
-        end
-
-        it 'should have the new accessor' do
-          expect(fieldset_object).to respond_to(:test_int)
-        end
-
-        it 'should have the correct default value' do
-          expect(fieldset_object.test_int).to eq(15)
-        end
-      end
-    end
-
-    context 'adding a Int32LE Field' do
-      before(:each) do
-        fieldset_class.int32LE(:test_int, { :value => 15})
-      end
-
-      it 'should set the prototypes correctly' do
-        expect(fieldset_class.prototypes).to include([:test_int, Net::NTLM::Int32LE, {:value=>15}])
-      end
-
-      it 'should set the names correctly' do
-        expect(fieldset_class.names).to include(:test_int)
-      end
-
-      it 'should set the types correctly' do
-        expect(fieldset_class.types).to include(Net::NTLM::Int32LE)
-      end
-
-      it 'should set the opts correctly' do
-        expect(fieldset_class.opts).to include({:value => 15})
-      end
-
-      context 'when creating an instance' do
-        let(:fieldset_object) do
-          fieldset_class.new
-        end
-
-        it 'should have the new accessor' do
-          expect(fieldset_object).to respond_to(:test_int)
-        end
-
-        it 'should have the correct default value' do
-          expect(fieldset_object.test_int).to eq(15)
-        end
-      end
-    end
-
-    context 'adding a Int64LE Field' do
-      before(:each) do
-        fieldset_class.int64LE(:test_int, { :value => 15})
-      end
-
-      it 'should set the prototypes correctly' do
-        expect(fieldset_class.prototypes).to include([:test_int, Net::NTLM::Int64LE, {:value=>15}])
-      end
-
-      it 'should set the names correctly' do
-        expect(fieldset_class.names).to include(:test_int)
-      end
-
-      it 'should set the types correctly' do
-        expect(fieldset_class.types).to include(Net::NTLM::Int64LE)
-      end
-
-      it 'should set the opts correctly' do
-        expect(fieldset_class.opts).to include({:value => 15})
-      end
-
-      context 'when creating an instance' do
-        let(:fieldset_object) do
-          fieldset_class.new
-        end
-
-        it 'should have the new accessor' do
-          expect(fieldset_object).to respond_to(:test_int)
-        end
-
-        it 'should have the correct default value' do
-          expect(fieldset_object.test_int).to eq(15)
-        end
-      end
-    end
-
-    context 'adding a SecurityBuffer Field' do
-      before(:each) do
-        fieldset_class.security_buffer(:test_buffer, { :value => 15})
-      end
-
-      it 'should set the prototypes correctly' do
-        expect(fieldset_class.prototypes).to include([:test_buffer, Net::NTLM::SecurityBuffer, {:value=>15}])
-      end
-
-      it 'should set the names correctly' do
-        expect(fieldset_class.names).to include(:test_buffer)
-      end
-
-      it 'should set the types correctly' do
-        expect(fieldset_class.types).to include(Net::NTLM::SecurityBuffer)
-      end
-
-      it 'should set the opts correctly' do
-        expect(fieldset_class.opts).to include({:value => 15})
-      end
-
-      context 'when creating an instance' do
-        let(:fieldset_object) do
-          fieldset_class.new
-        end
-
-        it 'should have the new accessor' do
-          expect(fieldset_object).to respond_to :test_buffer
-        end
-
-        it 'should have the correct default value' do
-          expect(fieldset_object.test_buffer).to eq(15)
-        end
-      end
-    end
-
-  end
-
-  context 'an instance' do
-
-    subject(:fieldset_object) do
-      # FieldSet Base Class and Message Base Class
-      # have no fields by default and thus cannot be initialized
-      # currently. Clumsy workaround for now.
-      if described_class.names.empty?
-        described_class.string(:test_string, { :value => 'Test', :active => true, :size => 4})
-      end
-      described_class.new
-    end
-
-    it { should respond_to :serialize }
-    it { should respond_to :parse }
-    it { should respond_to :size }
-    it { should respond_to :enable }
-    it { should respond_to :disable }
-
-    context 'fields' do
-      fields.each do |field|
-        it { should respond_to field[:name] }
-
-        context "#{field[:name]}" do
-          it "should be a #{field[:class].to_s}" do
-            expect(fieldset_object[field[:name]].class).to eq(field[:class])
-          end
-
-          it "should have a default value of #{field[:value]}" do
-            expect(fieldset_object[field[:name]].value).to eq(field[:value])
-          end
-
-          it "should have active set to #{field[:active]}" do
-            expect(fieldset_object[field[:name]].active).to eq(field[:active])
-          end
-        end
-      end
-    end
-
-  end
-end

data/spec/support/shared/examples/net/ntlm/int_shared.rb

@@ -1,43 +0,0 @@
-RSpec.shared_examples_for 'an integer field' do  |values|
-
-  subject do
-    described_class.new({
-      :value => values[:default],
-      :active => true
-    })
-  end
-
-  context '#serialize' do
-    it 'should serialize properly with an integer value' do
-      expect(subject.serialize).to eq(values[:default_hex])
-    end
-
-    it 'should raise an Exception for a String' do
-      subject.value = 'A'
-      expect {subject.serialize}.to raise_error
-    end
-
-    it 'should raise an Exception for Nil' do
-      subject.value = nil
-      expect {subject.serialize}.to raise_error
-    end
-  end
-
-  context '#parse' do
-    it "should parse a raw #{values[:bits].to_s}-bit integer from a string" do
-      expect(subject.parse(values[:alt_hex])).to eq(values[:size])
-      expect(subject.value).to eq(values[:alt])
-    end
-
-    it "should use an offset to find the #{values[:bits].to_s}-bit integer in the string" do
-      expect(subject.parse("Value:#{values[:alt_hex]}",6)).to eq(values[:size])
-      expect(subject.value).to eq(values[:alt])
-    end
-
-    it 'should return 0 and not change the value if the string is not big enough' do
-      expect(subject.parse(values[:small])).to eq(0)
-      expect(subject.value).to eq(values[:default])
-    end
-  end
-
-end

data/spec/support/shared/examples/net/ntlm/message_shared.rb

@@ -1,35 +0,0 @@
-RSpec.shared_examples_for 'a message' do |flags|
-
-  subject(:test_message) do
-    unless described_class.names.include?(:flag)
-      described_class.int32LE(:flag, {:value => Net::NTLM::DEFAULT_FLAGS[:TYPE1] })
-    end
-    described_class.new
-  end
-
-  it { should respond_to :has_flag? }
-  it { should respond_to :set_flag }
-  it { should respond_to :dump_flags }
-  it { should respond_to :encode64 }
-  it { should respond_to :decode64 }
-  it { should respond_to :head_size }
-  it { should respond_to :data_size }
-  it { should respond_to :size }
-  it { should respond_to :security_buffers }
-  it { should respond_to :deflag }
-  it { should respond_to :data_edge }
-
-  flags.each do |flag|
-    it "should be able to check if the #{flag} flag is set" do
-      expect(test_message.has_flag?(flag)).to be(true)
-    end
-  end
-
-
-  it 'should be able to set a new flag' do
-    test_message.set_flag(:DOMAIN_SUPPLIED)
-    expect(test_message.has_flag?(:DOMAIN_SUPPLIED)).to be(true)
-  end
-
-
-end