ruby_smb 3.0.6 → 3.1.0

data/lib/ruby_smb/server/share/provider/disk/processor.rb

@@ -0,0 +1,159 @@
+require 'ruby_smb/server/share/provider/processor'
+
+module RubySMB
+  class Server
+    module Share
+      module Provider
+        class Disk < Base
+          class Processor < Provider::Processor::Base
+            require 'ruby_smb/server/share/provider/disk/processor/close'
+            require 'ruby_smb/server/share/provider/disk/processor/create'
+            require 'ruby_smb/server/share/provider/disk/processor/query'
+            require 'ruby_smb/server/share/provider/disk/processor/read'
+
+            include RubySMB::Server::Share::Provider::Disk::Processor::Close
+            include RubySMB::Server::Share::Provider::Disk::Processor::Create
+            include RubySMB::Server::Share::Provider::Disk::Processor::Query
+            include RubySMB::Server::Share::Provider::Disk::Processor::Read
+
+            Handle = Struct.new(:remote_path, :local_path, :durable?)
+            def initialize(provider, server_client, session)
+              super
+              @handles = {}
+              @query_directory_context = {}
+            end
+
+            def maximal_access(path=nil)
+              RubySMB::SMB2::BitField::FileAccessMask.new(
+                read_attr: 1,
+                read_data: 1
+              )
+            end
+
+            private
+
+            def build_fscc_file_attributes(path)
+              file_attributes = Fscc::FileAttributes.new
+              if path.file?
+                file_attributes.normal = 1
+              elsif path.directory?
+                file_attributes.directory = 1
+              end
+              file_attributes
+            end
+
+            def build_fscc_file_information(path, info_class, rename: nil)
+              case info_class
+              when Fscc::FileInformation::FILE_EA_INFORMATION
+                info = Fscc::FileInformation::FileEaInformation.new
+              when Fscc::FileInformation::FILE_FULL_DIRECTORY_INFORMATION
+                info = Fscc::FileInformation::FileFullDirectoryInformation.new
+                set_common_info(info, path)
+                info.file_name = rename || path.basename.to_s
+              when Fscc::FileInformation::FILE_ID_BOTH_DIRECTORY_INFORMATION
+                info = Fscc::FileInformation::FileIdBothDirectoryInformation.new
+                set_common_info(info, path)
+                info.file_name = rename || path.basename.to_s
+              when Fscc::FileInformation::FILE_NETWORK_OPEN_INFORMATION
+                info = Fscc::FileInformation::FileNetworkOpenInformation.new
+                set_common_info(info, path)
+              when Fscc::FileInformation::FILE_STREAM_INFORMATION
+                  unless path.file?
+                    raise NotImplementedError, 'Can only generate FILE_STREAM_INFORMATION for files'
+                  end
+
+                  info = Fscc::FileInformation::FileStreamInformation.new(
+                    stream_size: path.size,
+                    stream_allocation_size: get_allocation_size(path),
+                    stream_name: '::$DATA'
+                  )
+              else
+                raise NotImplementedError, "Unsupported FSCC file information class: #{info_class} (#{Fscc::FileInformation.name(info_class)})"
+              end
+
+              # some have a next offset field that needs to be set accordingly
+              if info.respond_to?(:next_offset)
+                align = 8
+                info.next_offset = info.num_bytes + ((align - info.num_bytes % align) % align)
+              end
+
+              info
+            end
+
+            def get_allocation_size(path)
+              (path.size + (4095 - (path.size + 4095) % 4096))
+            end
+
+            def get_local_path(path)
+              case path
+              # SMB1 uses uint16_t file IDs
+              when ::BinData::Uint16le
+                local_path = @handles[path]&.local_path
+              # SMB2 uses a compound field for file IDs, so convert it to the binary rep and use that as the key
+              when Field::Smb2Fileid
+                local_path = @handles[path.to_binary_s]&.local_path
+              when ::String
+                path = path.encode.gsub(/\/|\\/, File::SEPARATOR)
+                path = path.delete_prefix(File::SEPARATOR)
+                local_path = (provider.path + path.encode).cleanpath
+                unless local_path == provider.path || local_path.to_s.start_with?(provider.path.to_s + '/')
+                  raise RuntimeError, "Directory traversal detected to: #{local_path}"
+                end
+              else
+                raise NotImplementedError, "Can not get the local path for: #{path.inspect}, type: #{path.class.inspect}"
+              end
+
+              local_path
+            end
+
+            # A bunch of structures have these common fields with the same meaning, so set them all here
+            def set_common_info(info, path)
+              set_common_timestamps(info, path)
+              if path.file?
+                info.end_of_file = path.size
+                info.allocation_size = get_allocation_size(path)
+              end
+              info.file_attributes = build_fscc_file_attributes(path)
+            end
+
+            def set_common_timestamps(info, path)
+              begin
+                info.create_time = path.birthtime
+              rescue NotImplementedError
+                logger.warn("The file system does not support #birthtime for #{path}")
+              end
+
+              info.last_access = path.atime
+              info.last_write = path.mtime
+              info.last_change = path.ctime
+            end
+
+            # Turn a wildcard expression into a regex. Not all wildcard
+            # characters are supported. Wildcards that can not be converted will
+            # raise a NotImplementedError.
+            #
+            # @param [String] wildcard The wildcard expression to convert.
+            # @return [Regexp] The converted expression.
+            # @raise [NotImplementedError] Raised when the wildcard can not be
+            #   converted.
+            def wildcard_to_regex(wildcard)
+              return Regexp.new('.*') if ['*.*', ''].include?(wildcard)
+
+              if wildcard.each_char.any? { |c| c == '<' || c == '>' }
+                # the < > wildcard operators are not supported
+                raise NotImplementedError, 'Unsupported wild card characters'
+              end
+
+              wildcard = Regexp.escape(wildcard)
+              wildcard = wildcard.gsub(/(\\\?)+$/) { |match| ".{0,#{match.length / 2}}"}
+              wildcard = wildcard.gsub('\?', '.')
+              wildcard = wildcard.gsub('\*', '.*')
+              wildcard = wildcard.gsub('"', '\.')
+              Regexp.new('^' + wildcard + '$')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/server/share/provider/disk.rb

@@ -1,5 +1,5 @@
-require 'zlib'
-require 'ruby_smb/server/share/provider/processor'
+require 'ruby_smb/server/share/provider/disk/file_system'
+require 'ruby_smb/server/share/provider/disk/processor'
 
 module RubySMB
   class Server
@@ -7,420 +7,8 @@ module RubySMB
       module Provider
         class Disk < Base
           TYPE = TYPE_DISK
-          class Processor < Processor::Base
-            Handle = Struct.new(:remote_path, :local_path, :durable?)
-            def initialize(provider, server_client, session)
-              super
-              @handles = {}
-              @query_directory_context = {}
-            end
-
-            def maximal_access(path=nil)
-              RubySMB::SMB2::BitField::FileAccessMask.new(
-                read_attr: 1,
-                read_data: 1
-              )
-            end
-
-            def do_close_smb2(request)
-              local_path = get_local_path(request.file_id)
-              if local_path.nil?
-                response = RubySMB::SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_FILE_CLOSED
-                return response
-              end
-
-              @handles.delete(request.file_id.to_binary_s)
-              response = RubySMB::SMB2::Packet::CloseResponse.new
-              set_common_info(response, local_path)
-              response.flags = 1
-              response
-            end
-
-            def do_create_smb2(request)
-              unless request.create_disposition == RubySMB::Dispositions::FILE_OPEN
-                logger.warn("Can not handle CREATE request for disposition: #{request.create_disposition}")
-                raise NotImplementedError
-              end
-
-              # process the delayed io fields
-              request.name.read_now!
-              unless request.contexts_offset == 0
-                request.contexts.read_now!
-                request.contexts.each do |context|
-                  context.name.read_now!
-                  context.data.read_now!
-                end
-              end
-
-              path = request.name.snapshot
-              path = path.encode.gsub('\\', File::SEPARATOR)
-              local_path = get_local_path(path)
-              unless local_path && (local_path.file? || local_path.directory?)
-                logger.warn("Requested path does not exist: #{local_path}")
-                response = RubySMB::SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_OBJECT_NAME_NOT_FOUND
-                return response
-              end
-
-              durable = false
-              response = RubySMB::SMB2::Packet::CreateResponse.new
-              response.create_action = RubySMB::CreateActions::FILE_OPENED
-              set_common_info(response, local_path)
-              response.file_id.persistent = Zlib::crc32(path)
-              response.file_id.volatile = rand(0xffffffff)
-
-              request.contexts.each do |req_ctx|
-                case req_ctx.name
-                when SMB2::CreateContext::CREATE_DURABLE_HANDLE
-                  # see: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/9adbc354-5fad-40e7-9a62-4a4b6c1ff8a0
-                  next if request.contexts.any? { |ctx| ctx.name == SMB2::CreateContext::CREATE_DURABLE_HANDLE_RECONNECT }
-
-                  if request.contexts.any? { |ctx| [ SMB2::CreateContext::CREATE_DURABLE_HANDLE_V2, SMB2::CreateContext::CREATE_DURABLE_HANDLE_RECONNECT_v2 ].include?(ctx.name) }
-                    response = RubySMB::SMB2::Packet::ErrorPacket.new
-                    response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_PARAMETER
-                    return response
-                  end
-
-                  durable = true
-                  res_ctx = SMB2::CreateContext::CreateDurableHandleResponse.new
-                when SMB2::CreateContext::CREATE_DURABLE_HANDLE_V2
-                  # see: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/33e6800a-adf5-4221-af27-7e089b9e81d1
-                  if request.contexts.any? { |ctx| [ SMB2::CreateContext::CREATE_DURABLE_HANDLE, SMB2::CreateContext::CREATE_DURABLE_HANDLE_RECONNECT, SMB2::CreateContext::CREATE_DURABLE_HANDLE_RECONNECT_v2 ].include?(ctx.name) }
-                    response = RubySMB::SMB2::Packet::ErrorPacket.new
-                    response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_PARAMETER
-                    return response
-                  end
-
-                  durable = true
-                  res_ctx = SMB2::CreateContext::CreateDurableHandleV2Response.new(
-                    timeout: 1000,
-                    flags: req_ctx.data.flags
-                  )
-                when SMB2::CreateContext::CREATE_QUERY_MAXIMAL_ACCESS
-                  res_ctx = SMB2::CreateContext::CreateQueryMaximalAccessResponse.new(
-                    maximal_access: maximal_access(path)
-                  )
-                when SMB2::CreateContext::CREATE_QUERY_ON_DISK_ID
-                  res_ctx = SMB2::CreateContext::CreateQueryOnDiskIdResponse.new(
-                    disk_file_id: local_path.stat.ino,
-                    volume_id: local_path.stat.dev
-                  )
-                else
-                  logger.warn("Can not handle CREATE context: #{req_ctx.name}")
-                  next
-                end
-
-                response.contexts << SMB2::CreateContext::CreateContextResponse.new(name: res_ctx.class::NAME, data: res_ctx)
-              end
-
-              if response.contexts.length > 0
-                # fixup the offsets
-                response.contexts[0...-1].each do |ctx|
-                  ctx.next_offset = ctx.num_bytes
-                end
-                response.contexts[-1].next_offset = 0
-                response.contexts_offset = response.buffer.abs_offset
-                response.contexts_length = response.buffer.num_bytes
-              else
-                response.contexts_offset = 0
-                response.contexts_length = 0
-              end
-
-              @handles[response.file_id.to_binary_s] = Handle.new(path, local_path, durable)
-              response
-            end
-
-            def do_query_directory_smb2(request)
-              local_path = get_local_path(request.file_id)
-              if local_path.nil?
-                response = RubySMB::SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_FILE_CLOSED
-                return response
-              end
-
-              # see: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/29dfcc9b-3aec-406b-abb5-0b4fe96712e2
-              info_class = request.file_information_class.snapshot
-              begin
-                # probe #build_info to see if it supports the requested info class
-                build_info(Pathname.new(__FILE__), info_class)
-              rescue NotImplementedError
-                logger.warn("Can not handle QUERY_DIRECTORY request for class: #{info_class}")
-                raise
-              end
-
-              unless local_path.directory?
-                response = SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_INVALID_PARAMETER
-                return response
-              end
-
-              search_pattern = request.name.snapshot.dup.encode
-              begin
-                search_regex = wildcard_to_regex(search_pattern)
-              rescue NotImplementedError
-                logger.warn("Can not handle QUERY_DIRECTORY wildcard pattern: #{search_pattern}")
-                raise
-              end
-
-              return_single = request.flags.return_single == 1
-
-              align = 8
-              infos = []
-              total_size = 0
-
-              if @query_directory_context[request.file_id.to_binary_s].nil? || request.flags.reopen == 1 || request.flags.restart_scans == 1
-                dirents = local_path.children.sort.to_a
-                dirents.unshift(local_path.parent) unless local_path.parent == local_path
-                dirents.unshift(local_path)
-                @query_directory_context[request.file_id.to_binary_s] = dirents
-              else
-                dirents = @query_directory_context[request.file_id.to_binary_s]
-              end
-
-              while dirents.length > 0
-                dirent = dirents.shift
-                next unless dirent.file? || dirent.directory? # filter out everything but files and directories
-
-                case dirent
-                when local_path
-                  dirent_name = '.'
-                when local_path.parent
-                  dirent_name = '..'
-                else
-                  dirent_name = dirent.basename.to_s
-                end
-                next unless search_regex.match?(dirent_name)
-
-                info = build_info(dirent, info_class, rename: dirent_name)
-                info_size = info.num_bytes + ((align - info.num_bytes % align) % align)
-                if total_size + info_size > request.output_length
-                  dirents.unshift(dirent) # no space left for this one so put it back
-                  break
-                end
-
-                infos << info
-                total_size += info_size
-                break if return_single
-              end
-
-              if infos.length == 0
-                response = SMB2::Packet::QueryDirectoryResponse.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_NO_MORE_FILES
-                return response
-              end
-
-              response = SMB2::Packet::QueryDirectoryResponse.new
-              infos.last.next_offset = 0 if infos.last
-              buffer = ""
-              infos.each do |info|
-                info = info.to_binary_s
-                buffer << info + "\x00".b * ((align - info.length % align) % align)
-              end
-              response.buffer = buffer
-              response
-            end
-
-            def do_query_info_smb2(request)
-              local_path = get_local_path(request.file_id)
-              if local_path.nil?
-                response = RubySMB::SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_FILE_CLOSED
-                return response
-              end
-
-              case request.info_type
-              when SMB2::SMB2_INFO_FILE
-                info = query_info_smb2_file(request, local_path)
-              when SMB2::SMB2_INFO_FILESYSTEM
-                info = query_info_smb2_filesystem(request, local_path)
-              else
-                logger.warn("Can not handle QUERY_INFO request for type: #{request.info_type}, class: #{request.file_information_class}")
-                raise NotImplementedError
-              end
-
-              response = SMB2::Packet::QueryInfoResponse.new
-              response.buffer = info.to_binary_s
-              response
-            end
-
-            def do_read_smb2(request)
-              local_path = get_local_path(request.file_id)
-              if local_path.nil?
-                response = RubySMB::SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_FILE_CLOSED
-                return response
-              end
-
-              raise NotImplementedError unless request.channel == SMB2::SMB2_CHANNEL_NONE
-
-              buffer = nil
-              local_path.open do |file|
-                file.seek(request.offset.snapshot)
-                buffer = file.read(request.read_length)
-              end
-
-              # see: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/21e8b343-34e9-4fca-8d93-03dd2d3e961e
-              if buffer.nil? || buffer.length == 0 || buffer.length < request.min_bytes
-                response = SMB2::Packet::ErrorPacket.new
-                response.smb2_header.nt_status = WindowsError::NTStatus::STATUS_END_OF_FILE
-                return response
-              end
-
-              response = SMB2::Packet::ReadResponse.new
-              response.data_length = buffer.length
-              response.buffer = buffer
-              response
-            end
-
-            private
-
-            def build_file_attributes(path)
-              file_attributes = Fscc::FileAttributes.new
-              if path.file?
-                file_attributes.normal = 1
-              elsif path.directory?
-                file_attributes.directory = 1
-              end
-              file_attributes
-            end
-
-            def build_info(path, info_class, rename: nil)
-              case info_class
-              when Fscc::FileInformation::FILE_ID_BOTH_DIRECTORY_INFORMATION
-                info = Fscc::FileInformation::FileIdBothDirectoryInformation.new
-                set_common_info(info, path)
-                info.file_name = rename || path.basename.to_s
-              when Fscc::FileInformation::FILE_FULL_DIRECTORY_INFORMATION
-                info = Fscc::FileInformation::FileFullDirectoryInformation.new
-                set_common_info(info, path)
-                info.file_name = rename || path.basename.to_s
-              else
-                raise NotImplementedError, "unsupported info class: #{info_class}"
-              end
-
-              align = 8
-              info.next_offset = info.num_bytes + ((align - info.num_bytes % align) % align)
-              info
-            end
-
-            def get_allocation_size(path)
-              (path.size + (4095 - (path.size + 4095) % 4096))
-            end
-
-            def get_local_path(path)
-              case path
-              when Field::Smb2Fileid
-                local_path = @handles[path.to_binary_s]&.local_path
-              when ::String
-                local_path = (provider.path + path.encode).cleanpath
-                # TODO: report / handle directory traversal issues more robustly
-                raise RuntimeError unless local_path == provider.path || local_path.to_s.start_with?(provider.path.to_s + '/')
-              else
-                raise NotImplementedError, "Can not get the local path for: #{path.inspect}"
-              end
-
-              local_path
-            end
-
-            def query_info_smb2_file(request, local_path)
-              raise ArgumentError unless request.info_type == SMB2::SMB2_INFO_FILE
-
-              case request.file_information_class
-              when Fscc::FileInformation::FILE_EA_INFORMATION
-                info = Fscc::FileInformation::FileEaInformation.new
-              when Fscc::FileInformation::FILE_NETWORK_OPEN_INFORMATION
-                info = Fscc::FileInformation::FileNetworkOpenInformation.new
-                set_common_info(info, local_path)
-              when Fscc::FileInformation::FILE_NORMALIZED_NAME_INFORMATION
-                info = Fscc::FileInformation::FileNameInformation.new(file_name: @handles[request.file_id.to_binary_s].remote_path)
-              when Fscc::FileInformation::FILE_STREAM_INFORMATION
-                raise NotImplementedError unless local_path.file?
-
-                info = Fscc::FileInformation::FileStreamInformation.new(
-                  stream_size: local_path.size,
-                  stream_allocation_size: get_allocation_size(local_path),
-                  stream_name: '::$DATA'
-                )
-              else
-                logger.warn("Can not handle QUERY_INFO request for type: #{request.info_type}, class: #{request.file_information_class}")
-                raise NotImplementedError
-              end
-
-              info
-            end
-
-            def query_info_smb2_filesystem(request, local_path)
-              raise ArgumentError unless request.info_type == SMB2::SMB2_INFO_FILESYSTEM
-
-              case request.file_information_class
-              when Fscc::FileSystemInformation::FILE_FS_ATTRIBUTE_INFORMATION
-                # emulate NTFS just like Samba does
-                info = Fscc::FileSystemInformation::FileFsAttributeInformation.new(
-                  file_system_attributes: {
-                    file_case_sensitive_search: 1,
-                    file_case_preserved_names: 1,
-                    file_unicode_on_disk: 1,
-                    file_supports_object_ids: 1,
-                  },
-                  maximum_component_name_length: 255,
-                  file_system_name: 'NTFS'
-                )
-              when Fscc::FileSystemInformation::FILE_FS_VOLUME_INFORMATION
-                info = Fscc::FileSystemInformation::FileFsVolumeInformation.new(
-                  volume_serial_number: provider.path.stat.ino,
-                  volume_label: provider.name
-                )
-              else
-                logger.warn("Can not handle QUERY_INFO request for type: #{request.info_type}, class: #{request.file_information_class}")
-                raise NotImplementedError
-              end
-
-              info
-            end
-
-            # A bunch of structures have these common fields with the same meaning, so set them all here
-            def set_common_info(info, path)
-              begin
-                info.create_time = path.birthtime
-              rescue NotImplementedError
-                logger.warn("The file system does not support #birthtime for #{path}")
-              end
-
-              info.last_access = path.atime
-              info.last_write = path.mtime
-              info.last_change = path.ctime
-              if path.file?
-                info.end_of_file = path.size
-                info.allocation_size = get_allocation_size(path)
-              end
-              info.file_attributes = build_file_attributes(path)
-            end
-
-            # Turn a wildcard expression into a regex. Not all wildcard
-            # characters are supported. Wildcards that can not be converted will
-            # raise a NotImplementedError.
-            #
-            # @param [String] wildcard The wildcard expression to convert.
-            # @return [Regexp] The converted expression.
-            # @raise [NotImplementedError] Raised when the wildcard can not be
-            #   converted.
-            def wildcard_to_regex(wildcard)
-              return Regexp.new('.*') if ['*.*', ''].include?(wildcard)
-
-              if wildcard.each_char.any? { |c| c == '<' || c == '>' }
-                # the < > wildcard operators are not supported
-                raise NotImplementedError
-              end
-
-              wildcard = Regexp.escape(wildcard)
-              wildcard = wildcard.gsub(/(\\\?)+$/) { |match| ".{0,#{match.length / 2}}"}
-              wildcard = wildcard.gsub('\?', '.')
-              wildcard = wildcard.gsub('\*', '.*')
-              wildcard = wildcard.gsub('"', '\.')
-              Regexp.new('^' + wildcard + '$')
-            end
-          end
+          # emulate NTFS just like Samba does
+          FILE_SYSTEM = FileSystem::NTFS
 
           def initialize(name, path)
             path = Pathname.new(File.expand_path(path))

data/lib/ruby_smb/server/share/provider/pipe.rb

@@ -6,12 +6,12 @@ module RubySMB
       module Provider
         class Pipe < Base
           TYPE = TYPE_PIPE
-          class Processor < Processor::Base
+          class Processor < Provider::Processor::Base
           end
         end
 
         class IpcPipe < Pipe
-          class Processor < Processor::Base
+          class Processor < Provider::Processor::Base
             def maximal_access(path=nil)
               RubySMB::SMB2::BitField::DirectoryAccessMask.read([0x001f00a9].pack('V'))
             end

data/lib/ruby_smb/server/share/provider/processor.rb

@@ -25,6 +25,22 @@ module RubySMB
             def disconnect!
             end
 
+            def do_close_smb1(request)
+              raise NotImplementedError
+            end
+
+            def do_nt_create_andx_smb1(request)
+              raise NotImplementedError
+            end
+
+            def do_read_andx_smb1(request)
+              raise NotImplementedError
+            end
+
+            def do_transactions2_smb1(request)
+              raise NotImplementedError
+            end
+
             def do_close_smb2(request)
               raise NotImplementedError
             end

data/lib/ruby_smb/signing.rb

@@ -6,17 +6,31 @@ module RubySMB
     #   @return [String]
     attr_accessor :session_key
 
-    # Take an SMB1 packet and sign it.
+    # Take an SMB1 packet and sign it. This version is an instance method that
+    # accesses the necessary values from the object instance.
     #
     # @param [RubySMB::GenericPacket] packet The packet to sign.
     # @return [RubySMB::GenericPacket] the signed packet
     def smb1_sign(packet)
+      packet = Signing::smb1_sign(packet, @session_key, @sequence_counter)
+      @sequence_counter += 1
+
+      packet
+    end
+
+    # Take an SMB1 packet and sign it. This version is a module function that
+    # requires the necessary values to be explicitly passed to it.
+    #
+    # @param [RubySMB::GenericPacket] packet The packet to sign.
+    # @param [String] session_key The key to use for signing.
+    # @param [Integer] sequence_counter The sequence counter of packet to be sent.
+    # @return [RubySMB::GenericPacket] the signed packet
+    def self.smb1_sign(packet, session_key, sequence_counter)
       # Pack the Sequence counter into a int64le
-      packed_sequence_counter = [@sequence_counter].pack('Q<')
+      packed_sequence_counter = [sequence_counter].pack('Q<')
       packet.smb_header.security_features = packed_sequence_counter
-      signature = OpenSSL::Digest::MD5.digest(@session_key + packet.to_binary_s)[0, 8]
+      signature = OpenSSL::Digest::MD5.digest(session_key + packet.to_binary_s)[0, 8]
       packet.smb_header.security_features = signature
-      @sequence_counter += 1
 
       packet
     end

data/lib/ruby_smb/smb1/commands.rb

@@ -12,6 +12,7 @@ module RubySMB
       SMB_COM_NEGOTIATE               = 0x72
       SMB_COM_SESSION_SETUP_ANDX      = 0x73
       SMB_COM_LOGOFF                  = 0x74
+      SMB_COM_LOGOFF_ANDX             = 0x74
       SMB_COM_TREE_CONNECT            = 0x75
       SMB_COM_NT_TRANSACT             = 0xA0
       SMB_COM_NT_TRANSACT_SECONDARY   = 0xA1