ruby_smb 2.0.11 → 3.0.1

data/spec/lib/ruby_smb/dcerpc/wkssvc/netr_wksta_get_info_response_spec.rb

@@ -0,0 +1,410 @@
+RSpec.describe RubySMB::Dcerpc::Wkssvc::WkstaInfo102 do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :wki102_platform_id }
+  it { is_expected.to respond_to :wki102_computername }
+  it { is_expected.to respond_to :wki102_langroup }
+  it { is_expected.to respond_to :wki102_ver_major }
+  it { is_expected.to respond_to :wki102_ver_minor }
+  it { is_expected.to respond_to :wki102_lanroot }
+  it { is_expected.to respond_to :wki102_logged_on_users }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+  it 'it is a Ndr::NdrStruct' do
+    expect(described_class).to be < RubySMB::Dcerpc::Ndr::NdrStruct
+  end
+  describe '#wki102_platform_id' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.wki102_platform_id).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#wki102_computername' do
+    it 'is a Ndr::NdrWideStringzPtr' do
+      expect(packet.wki102_computername).to be_a(RubySMB::Dcerpc::Ndr::NdrWideStringzPtr)
+    end
+  end
+  describe '#wki102_langroup' do
+    it 'is a Ndr::NdrWideStringzPtr' do
+      expect(packet.wki102_langroup).to be_a(RubySMB::Dcerpc::Ndr::NdrWideStringzPtr)
+    end
+  end
+  describe '#wki102_ver_major' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.wki102_ver_major).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#wki102_ver_minor' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.wki102_ver_minor).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#wki102_lanroot' do
+    it 'is a Ndr::NdrWideStringzPtr' do
+      expect(packet.wki102_lanroot).to be_a(RubySMB::Dcerpc::Ndr::NdrWideStringzPtr)
+    end
+  end
+  describe '#wki102_logged_on_users' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.wki102_logged_on_users).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  it 'reads itself' do
+    new_class = described_class.new(
+      wki102_platform_id: 500,
+      wki102_computername: 'MYCOMPUTER',
+      wki102_langroup: 'MYDOMAIN',
+      wki102_ver_major: 6,
+      wki102_ver_minor: 2,
+      wki102_lanroot: 'MYLANROOT',
+      wki102_logged_on_users: 4,
+    )
+    expect(packet.read(new_class.to_binary_s)).to eq(
+      {
+        wki102_platform_id: 500,
+        wki102_computername: 'MYCOMPUTER'.encode('utf-16le'),
+        wki102_langroup: 'MYDOMAIN'.encode('utf-16le'),
+        wki102_ver_major: 6,
+        wki102_ver_minor: 2,
+        wki102_lanroot: 'MYLANROOT'.encode('utf-16le'),
+        wki102_logged_on_users: 4,
+      }
+    )
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::Wkssvc::PwkstaInfo102 do
+  subject(:packet) { described_class.new }
+
+  it 'is a WkstaInfo102' do
+    expect(packet).to be_a(RubySMB::Dcerpc::Wkssvc::WkstaInfo102)
+  end
+  it 'is a NDR Pointer' do
+    expect(described_class).to be_a(RubySMB::Dcerpc::Ndr::PointerClassPlugin)
+  end
+  it 'reads itself' do
+    new_class = described_class.new(
+      wki102_platform_id: 500,
+      wki102_computername: 'MYCOMPUTER',
+      wki102_langroup: 'MYDOMAIN',
+      wki102_ver_major: 6,
+      wki102_ver_minor: 2,
+      wki102_lanroot: 'MYLANROOT',
+      wki102_logged_on_users: 4,
+    )
+    expect(packet.read(new_class.to_binary_s)).to eq(
+      {
+        wki102_platform_id: 500,
+        wki102_computername: 'MYCOMPUTER'.encode('utf-16le'),
+        wki102_langroup: 'MYDOMAIN'.encode('utf-16le'),
+        wki102_ver_major: 6,
+        wki102_ver_minor: 2,
+        wki102_lanroot: 'MYLANROOT'.encode('utf-16le'),
+        wki102_logged_on_users: 4,
+      }
+    )
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::Wkssvc::WkstaInfo101 do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :wki101_platform_id }
+  it { is_expected.to respond_to :wki101_computername }
+  it { is_expected.to respond_to :wki101_langroup }
+  it { is_expected.to respond_to :wki101_ver_major }
+  it { is_expected.to respond_to :wki101_ver_minor }
+  it { is_expected.to respond_to :wki101_lanroot }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+  it 'it is a Ndr::NdrStruct' do
+    expect(described_class).to be < RubySMB::Dcerpc::Ndr::NdrStruct
+  end
+  describe '#wki101_platform_id' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.wki101_platform_id).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#wki101_computername' do
+    it 'is a Ndr::NdrWideStringzPtr' do
+      expect(packet.wki101_computername).to be_a(RubySMB::Dcerpc::Ndr::NdrWideStringzPtr)
+    end
+  end
+  describe '#wki101_langroup' do
+    it 'is a Ndr::NdrWideStringzPtr' do
+      expect(packet.wki101_langroup).to be_a(RubySMB::Dcerpc::Ndr::NdrWideStringzPtr)
+    end
+  end
+  describe '#wki101_ver_major' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.wki101_ver_major).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#wki101_ver_minor' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.wki101_ver_minor).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#wki101_lanroot' do
+    it 'is a Ndr::NdrWideStringzPtr' do
+      expect(packet.wki101_lanroot).to be_a(RubySMB::Dcerpc::Ndr::NdrWideStringzPtr)
+    end
+  end
+  it 'reads itself' do
+    new_class = described_class.new(
+      wki101_platform_id: 500,
+      wki101_computername: 'MYCOMPUTER',
+      wki101_langroup: 'MYDOMAIN',
+      wki101_ver_major: 6,
+      wki101_ver_minor: 2,
+      wki101_lanroot: 'MYLANROOT'
+    )
+    expect(packet.read(new_class.to_binary_s)).to eq(
+      {
+        wki101_platform_id: 500,
+        wki101_computername: 'MYCOMPUTER'.encode('utf-16le'),
+        wki101_langroup: 'MYDOMAIN'.encode('utf-16le'),
+        wki101_ver_major: 6,
+        wki101_ver_minor: 2,
+        wki101_lanroot: 'MYLANROOT'.encode('utf-16le')
+      }
+    )
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::Wkssvc::PwkstaInfo101 do
+  subject(:packet) { described_class.new }
+
+  it 'is a WkstaInfo101' do
+    expect(packet).to be_a(RubySMB::Dcerpc::Wkssvc::WkstaInfo101)
+  end
+  it 'is a NDR Pointer' do
+    expect(described_class).to be_a(RubySMB::Dcerpc::Ndr::PointerClassPlugin)
+  end
+  it 'reads itself' do
+    new_class = described_class.new(
+      wki101_platform_id: 500,
+      wki101_computername: 'MYCOMPUTER',
+      wki101_langroup: 'MYDOMAIN',
+      wki101_ver_major: 6,
+      wki101_ver_minor: 2,
+      wki101_lanroot: 'MYLANROOT'
+    )
+    expect(packet.read(new_class.to_binary_s)).to eq(
+      {
+        wki101_platform_id: 500,
+        wki101_computername: 'MYCOMPUTER'.encode('utf-16le'),
+        wki101_langroup: 'MYDOMAIN'.encode('utf-16le'),
+        wki101_ver_major: 6,
+        wki101_ver_minor: 2,
+        wki101_lanroot: 'MYLANROOT'.encode('utf-16le')
+      }
+    )
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::Wkssvc::WkstaInfo100 do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :wki100_platform_id }
+  it { is_expected.to respond_to :wki100_computername }
+  it { is_expected.to respond_to :wki100_langroup }
+  it { is_expected.to respond_to :wki100_ver_major }
+  it { is_expected.to respond_to :wki100_ver_minor }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+  it 'it is a Ndr::NdrStruct' do
+    expect(described_class).to be < RubySMB::Dcerpc::Ndr::NdrStruct
+  end
+  describe '#wki100_platform_id' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.wki100_platform_id).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#wki100_computername' do
+    it 'is a Ndr::NdrWideStringzPtr' do
+      expect(packet.wki100_computername).to be_a(RubySMB::Dcerpc::Ndr::NdrWideStringzPtr)
+    end
+  end
+  describe '#wki100_langroup' do
+    it 'is a Ndr::NdrWideStringzPtr' do
+      expect(packet.wki100_langroup).to be_a(RubySMB::Dcerpc::Ndr::NdrWideStringzPtr)
+    end
+  end
+  describe '#wki100_ver_major' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.wki100_ver_major).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#wki100_ver_minor' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.wki100_ver_minor).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+
+  it 'reads itself' do
+    new_class = described_class.new(
+      wki100_platform_id: 500,
+      wki100_computername: 'MYCOMPUTER',
+      wki100_langroup: 'MYDOMAIN',
+      wki100_ver_major: 6,
+      wki100_ver_minor: 2
+    )
+    expect(packet.read(new_class.to_binary_s)).to eq(
+      {
+        wki100_platform_id: 500,
+        wki100_computername: 'MYCOMPUTER'.encode('utf-16le'),
+        wki100_langroup: 'MYDOMAIN'.encode('utf-16le'),
+        wki100_ver_major: 6,
+        wki100_ver_minor: 2
+      }
+    )
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::Wkssvc::PwkstaInfo100 do
+  subject(:packet) { described_class.new }
+
+  it 'is a WkstaInfo100' do
+    expect(packet).to be_a(RubySMB::Dcerpc::Wkssvc::WkstaInfo100)
+  end
+  it 'is a NDR Pointer' do
+    expect(described_class).to be_a(RubySMB::Dcerpc::Ndr::PointerClassPlugin)
+  end
+  it 'reads itself' do
+    new_class = described_class.new(
+      wki100_platform_id: 500,
+      wki100_computername: 'MYCOMPUTER',
+      wki100_langroup: 'MYDOMAIN',
+      wki100_ver_major: 6,
+      wki100_ver_minor: 2
+    )
+    expect(packet.read(new_class.to_binary_s)).to eq(
+      {
+        wki100_platform_id: 500,
+        wki100_computername: 'MYCOMPUTER'.encode('utf-16le'),
+        wki100_langroup: 'MYDOMAIN'.encode('utf-16le'),
+        wki100_ver_major: 6,
+        wki100_ver_minor: 2
+      }
+    )
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::Wkssvc::LpwkstaInfo do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :level }
+  it { is_expected.to respond_to :info }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+  it 'it is a Ndr::NdrStruct' do
+    expect(described_class).to be < RubySMB::Dcerpc::Ndr::NdrStruct
+  end
+  describe '#level' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.level).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#info' do
+    it 'is a BinData:Choice structure' do
+      expect(packet.info).to be_a BinData::Choice
+    end
+    it 'selects a structure according to :level value' do
+      packet.level = RubySMB::Dcerpc::Wkssvc::WKSTA_INFO_100
+      expect(packet.info.send(:current_choice)).to be_a(RubySMB::Dcerpc::Wkssvc::WkstaInfo100)
+    end
+  end
+  it 'reads itself' do
+    new_class = described_class.new(
+      level: RubySMB::Dcerpc::Wkssvc::WKSTA_INFO_100,
+      info: {
+        wki100_platform_id: 500,
+        wki100_computername: 'MYCOMPUTER',
+        wki100_langroup: 'MYDOMAIN',
+        wki100_ver_major: 6,
+        wki100_ver_minor: 2
+      }
+    )
+    expect(packet.read(new_class.to_binary_s)).to eq(
+      {
+        level: RubySMB::Dcerpc::Wkssvc::WKSTA_INFO_100,
+        info: {
+          wki100_platform_id: 500,
+          wki100_computername: 'MYCOMPUTER'.encode('utf-16le'),
+          wki100_langroup: 'MYDOMAIN'.encode('utf-16le'),
+          wki100_ver_major: 6,
+          wki100_ver_minor: 2
+        }
+      }
+    )
+  end
+end
+
+RSpec.describe RubySMB::Dcerpc::Wkssvc::NetrWkstaGetInfoResponse do
+  subject(:packet) { described_class.new }
+
+  it { is_expected.to respond_to :wksta_info }
+  it { is_expected.to respond_to :error_status }
+  it { is_expected.to respond_to :opnum }
+
+  it 'is little endian' do
+    expect(described_class.fields.instance_variable_get(:@hints)[:endian]).to eq :little
+  end
+  it 'is a BinData::Record' do
+    expect(packet).to be_a(BinData::Record)
+  end
+  describe '#wksta_info' do
+    it 'is a LpwkstaInfo structure' do
+      expect(packet.wksta_info).to be_a RubySMB::Dcerpc::Wkssvc::LpwkstaInfo
+    end
+  end
+  describe '#error_status' do
+    it 'is a NdrUint32 structure' do
+      expect(packet.error_status).to be_a RubySMB::Dcerpc::Ndr::NdrUint32
+    end
+  end
+  describe '#initialize_instance' do
+    it 'sets #opnum to NETR_WKSTA_GET_INFO constant' do
+      expect(packet.opnum).to eq(RubySMB::Dcerpc::Wkssvc::NETR_WKSTA_GET_INFO)
+    end
+  end
+  it 'reads itself' do
+    new_class = described_class.new(
+      wksta_info: {
+        level: RubySMB::Dcerpc::Wkssvc::WKSTA_INFO_100,
+        info: {
+          wki100_platform_id: 500,
+          wki100_computername: 'MYCOMPUTER',
+          wki100_langroup: 'MYDOMAIN',
+          wki100_ver_major: 6,
+          wki100_ver_minor: 2
+        }
+      },
+      error_status: 0
+    )
+    expect(packet.read(new_class.to_binary_s)).to eq(
+      {
+        wksta_info: {
+          level: RubySMB::Dcerpc::Wkssvc::WKSTA_INFO_100,
+          info: {
+            wki100_platform_id: 500,
+            wki100_computername: 'MYCOMPUTER'.encode('utf-16le'),
+            wki100_langroup: 'MYDOMAIN'.encode('utf-16le'),
+            wki100_ver_major: 6,
+            wki100_ver_minor: 2
+          }
+        },
+        error_status: 0
+      }
+    )
+  end
+end
+

data/spec/lib/ruby_smb/dcerpc/wkssvc_spec.rb

@@ -0,0 +1,70 @@
+RSpec.describe RubySMB::Dcerpc::Wkssvc do
+  let(:wkssvc) do
+    RubySMB::SMB1::Pipe.new(
+      tree: double('Tree'),
+      response: RubySMB::SMB1::Packet::NtCreateAndxResponse.new,
+      name: 'wkssvc'
+    )
+  end
+
+  describe '#netr_wksta_get_info' do
+    let(:wkst_netr_wksta_get_info_request) { double('NetrWkstaGetInfoRequest') }
+    let(:response) { double('Response') }
+    let(:wkst_netr_wksta_get_info_response) { double('NetrWkstaGetInfoResponse') }
+    let(:info) { double('info') }
+    before :example do
+      allow(described_class::NetrWkstaGetInfoRequest).to receive(:new).and_return(wkst_netr_wksta_get_info_request)
+      allow(wkssvc).to receive(:dcerpc_request).and_return(response)
+      allow(described_class::NetrWkstaGetInfoResponse).to receive(:read).and_return(wkst_netr_wksta_get_info_response)
+      allow(wkst_netr_wksta_get_info_response).to receive(:error_status).and_return(WindowsError::Win32::ERROR_SUCCESS)
+      allow(wkst_netr_wksta_get_info_response).to receive_message_chain(:wksta_info, :info => info)
+    end
+
+    it 'sets the request with the expected values' do
+      wkssvc.netr_wksta_get_info
+      expect(described_class::NetrWkstaGetInfoRequest).to have_received(:new).with(
+        server_name: "\x00",
+        level: described_class::WKSTA_INFO_100
+      )
+    end
+    it 'send the expected request structure' do
+      wkssvc.netr_wksta_get_info
+      expect(wkssvc).to have_received(:dcerpc_request).with(wkst_netr_wksta_get_info_request)
+    end
+    context 'when an IOError occurs while parsing the response' do
+      it 'raises a RubySMB::Dcerpc::Error::InvalidPacket' do
+        allow(described_class::NetrWkstaGetInfoResponse).to receive(:read).and_raise(IOError)
+        expect { wkssvc.netr_wksta_get_info }.to raise_error(RubySMB::Dcerpc::Error::InvalidPacket)
+      end
+    end
+    context 'when the response error status is not WindowsError::Win32::ERROR_SUCCESS' do
+      it 'raises a RubySMB::Dcerpc::Error::WinregError' do
+        allow(wkst_netr_wksta_get_info_response).to receive(:error_status).and_return(WindowsError::Win32::ERROR_INVALID_DATA)
+        expect { wkssvc.netr_wksta_get_info }.to raise_error(RubySMB::Dcerpc::Error::WkssvcError)
+      end
+    end
+    it 'returns the expected handler' do
+      expect(wkssvc.netr_wksta_get_info).to eq(info)
+    end
+    context 'with a real binary stream' do
+      it 'returns the expected value' do
+        raw_response =
+          "d\x00\x00\x00\x00\x00\x02\x00\xF4\x01\x00\x00\x04\x00\x02\x00\b"\
+          "\x00\x02\x00\x06\x00\x00\x00\x02\x00\x00\x00\x0F\x00\x00\x00\x00"\
+          "\x00\x00\x00\x0F\x00\x00\x00W\x00I\x00N\x00-\x00A\x00B\x00C\x00D"\
+          "\x00E\x00F\x00C\x007\x006\x008\x00\x00\x00\x00\x00\x06\x00\x00"\
+          "\x00\x00\x00\x00\x00\x06\x00\x00\x00M\x00Y\x00L\x00A\x00B\x00\x00"\
+          "\x00\x00\x00\x00\x00"
+        allow(wkssvc).to receive(:dcerpc_request).and_return(raw_response)
+        allow(described_class::NetrWkstaGetInfoResponse).to receive(:read).and_call_original
+        expect(wkssvc.netr_wksta_get_info).to eq({
+          wki100_platform_id: 500,
+          wki100_computername: "WIN-ABCDEFC768".encode('utf-16le'),
+          wki100_langroup: "MYLAB".encode('utf-16le'),
+          wki100_ver_major: 6,
+          wki100_ver_minor: 2
+        })
+      end
+    end
+  end
+end

data/spec/lib/ruby_smb/field/nt_status_spec.rb

@@ -3,8 +3,12 @@ RSpec.describe RubySMB::Field::NtStatus do
 
   it { is_expected.to respond_to :to_nt_status }
 
-  it 'is a Unsigned 32-bit little endian integer' do
-    expect(nt_status).to be_a BinData::Uint32le
+  it 'uses an internal Unsigned 32-bit little endian integer' do
+    expect(nt_status.val).to be_a BinData::Uint32le
+  end
+
+  it 'returns an integer value' do
+    expect(nt_status.value).to be_a Integer
   end
 
   describe '#to_nt_status' do

data/spec/lib/ruby_smb/field/string16_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe RubySMB::Field::String16 do
+  subject(:field) { described_class.new }
+
+  it 'is a BinData::String' do
+    expect(field).to be_a BinData::String
+  end
+
+  it 'converts to utf-16le when assigning a String' do
+    expect(field.assign('Test'.encode('ASCII-8BIT')).encoding).to be Encoding::UTF_16LE
+  end
+
+  it 'makes sure snapshot returns a utf-16le string' do
+    field.new('Test'.encode('ASCII-8BIT'))
+    expect(field.snapshot.encoding).to be Encoding::UTF_16LE
+  end
+
+  it 'makes sure read operation returns a utf-16le string' do
+    field.read('Test'.encode('ASCII-8BIT'))
+    expect(field.snapshot.encoding).to be Encoding::UTF_16LE
+  end
+
+end

data/spec/lib/ruby_smb/gss/provider/ntlm/authenticator_spec.rb

@@ -13,6 +13,10 @@ RSpec.describe RubySMB::Gss::Provider::NTLM::Authenticator do
     Net::NTLM::Message::Type2.new.response(user: username, password: '', domain: domain)
   end
 
+  before(:each) do
+    allow(authenticator).to receive(:logger).and_return(Logger.new(IO::NULL))
+  end
+
   describe '#initialize' do
     it 'defaults to a null session key' do
       expect(authenticator.session_key).to be_nil

data/spec/lib/ruby_smb/gss/provider/ntlm/os_version_spec.rb

@@ -15,7 +15,7 @@ RSpec.describe RubySMB::Gss::Provider::NTLM::OSVersion do
   describe '#read' do
     it 'reads a packed version correctly' do
       # Version 6.1 (Build 7601); NTLM Current Revision 15
-      os_version = RubySMB::Gss::Provider::NTLM::OSVersion.read("\x06\x01\x1d\xb1\x00\x00\x00\x0f")
+      os_version = RubySMB::Gss::Provider::NTLM::OSVersion.read("\x06\x01\xb1\x1d\x00\x00\x00\x0f")
       expect(os_version.major).to eq 6
       expect(os_version.minor).to eq 1
       expect(os_version.build).to eq 7601

data/spec/lib/ruby_smb/server/server_client_spec.rb

@@ -5,33 +5,24 @@ RSpec.describe RubySMB::Server::ServerClient do
   subject(:server_client) { described_class.new(server, dispatcher) }
 
   it { is_expected.to respond_to :dialect }
-  it { is_expected.to respond_to :identity }
-  it { is_expected.to respond_to :state }
-  it { is_expected.to respond_to :session_key }
+  it { is_expected.to respond_to :session_table }
 
   describe '#disconnect!' do
     it 'closes the socket' do
+      expect(dispatcher.tcp_socket).to receive(:closed?).with(no_args).and_return(false)
       expect(dispatcher.tcp_socket).to receive(:close).with(no_args).and_return(nil)
       server_client.disconnect!
     end
   end
 
   describe '#initialize' do
-    it 'starts in the negotiate state' do
-      expect(server_client.state).to eq :negotiate
-    end
-
     it 'starts without a dialect' do
       expect(server_client.dialect).to be_nil
       expect(server_client.metadialect).to be_nil
     end
 
-    it 'starts without an identity' do
-      expect(server_client.identity).to be_nil
-    end
-
-    it 'starts without a session_key' do
-      expect(server_client.session_key).to be_nil
+    it 'starts without any sessions' do
+      expect(server_client.session_table).to be_empty
     end
 
     it 'creates a new authenticator instance' do
@@ -66,33 +57,30 @@ RSpec.describe RubySMB::Server::ServerClient do
     before(:each) do
       expect(server_client).to receive(:recv_packet).and_return(packet)
       # this hook should ensure that the dispatcher loop returns after processing a single request
-      expect(dispatcher.tcp_socket).to receive(:closed?).and_return(true)
+      expect(dispatcher.tcp_socket).to receive(:closed?).with(no_args).and_return(true)
+      expect(server_client).to receive(:disconnect!).with(no_args).and_return(nil)
     end
 
-    it 'calls #handle_negotiate when the state is negotiate' do
+    it 'calls #handle_negotiate when the dialect is nil' do
       expect(server_client).to receive(:handle_negotiate).with(packet).and_return(nil)
-      server_client.instance_eval { @state = :negotiate }
-      server_client.run
-    end
-
-    it 'calls #handle_session_setup when the state is session_setup' do
-      expect(server_client).to receive(:handle_session_setup).with(packet).and_return(nil)
-      server_client.instance_eval { @state = :session_setup }
+      server_client.instance_eval { @dialect = nil }
       server_client.run
     end
 
-    it 'calls #authenticated when the state is authenticated' do
-      expect(server_client).to receive(:handle_authenticated).with(packet).and_return(nil)
-      server_client.instance_eval { @state = :authenticated }
+    it 'calls #handle_smb when the dialect is not nil' do
+      expect(server_client).to receive(:handle_smb).with(packet).and_return(nil)
+      server_client.instance_eval { @dialect = true }
       server_client.run
     end
   end
 
   describe '#send_packet' do
-    let(:packet) { RubySMB::GenericPacket.new }
+    let(:session_id) { rand(0xffffffff) }
+    let(:packet) { RubySMB::SMB2::Packet::SessionSetupResponse.new(smb2_header: { session_id: session_id }) }
 
     before(:each) do
       expect(dispatcher).to receive(:send_packet).with(packet).and_return(nil)
+      server_client.session_table[session_id] = RubySMB::Server::Session.new(session_id)
     end
 
     it 'sends a packet to the dispatcher' do
@@ -105,40 +93,35 @@ RSpec.describe RubySMB::Server::ServerClient do
           server_client.instance_eval { @dialect = dialect }
         end
 
-        context 'and the state is authenticated' do
+        context 'and the identity is anonymous' do
           before(:each) do
-            server_client.instance_eval { @state = :authenticated }
+            server_client.session_table[session_id].user_id = RubySMB::Gss::Provider::IDENTITY_ANONYMOUS
           end
 
-          context 'and the identity is anonymous' do
-            before(:each) do
-              server_client.instance_eval { @identity = RubySMB::Gss::Provider::IDENTITY_ANONYMOUS }
-            end
-
-            it 'does not sign packets' do
-              expect(server_client).to_not receive(:smb2_sign)
-              expect(server_client).to_not receive(:smb3_sign)
-              server_client.send_packet(packet)
-            end
+          it 'does not sign packets' do
+            expect(RubySMB::Signing).to_not receive(:smb2_sign)
+            expect(RubySMB::Signing).to_not receive(:smb3_sign)
+            server_client.send_packet(packet)
           end
+        end
 
-          context 'and the identity is not anonymous' do
-            before(:each) do
-              server_client.instance_eval { @identity = 'WORKGROUP\RubySMB'; @session_key = Random.new.bytes(16) }
-            end
+        context 'and the identity is not anonymous' do
+          before(:each) do
+            server_client.session_table[session_id].user_id = 'WORKGROUP\RubySMB'
+            server_client.session_table[session_id].key = Random.new.bytes(16)
+          end
 
-            it 'does sign packets' do
-              packet = RubySMB::GenericPacket.new
-              dialect_family = RubySMB::Dialect[dialect].family
-              if dialect_family == RubySMB::Dialect::FAMILY_SMB2
-                expect(server_client).to receive(:smb2_sign).with(packet).and_return(packet)
-                expect(server_client).to_not receive(:smb3_sign)
-              elsif dialect_family == RubySMB::Dialect::FAMILY_SMB3
-                expect(server_client).to receive(:smb3_sign).with(packet).and_return(packet)
-                expect(server_client).to_not receive(:smb2_sign)
-              end
-              server_client.send_packet(packet)
+          it 'does sign packets' do
+            dialect_family = RubySMB::Dialect[dialect].family
+            session = server_client.session_table[session_id]
+            if dialect_family == RubySMB::Dialect::FAMILY_SMB2
+              expect(RubySMB::Signing).to receive(:smb2_sign).with(packet, session.key).and_return(packet)
+              expect(RubySMB::Signing).to_not receive(:smb3_sign)
+            elsif dialect_family == RubySMB::Dialect::FAMILY_SMB3
+              expect(RubySMB::Signing).to receive(:smb3_sign).with(packet, session.key, dialect, any_args).and_return(packet)
+              expect(RubySMB::Signing).to_not receive(:smb2_sign)
             end
+            server_client.send_packet(packet)
           end
         end
       end