ruby_smb 3.0.6 → 3.1.2

data/lib/ruby_smb/server/share/provider/virtual_disk/virtual_pathname.rb

@@ -0,0 +1,196 @@
+module RubySMB
+  class Server
+    module Share
+      module Provider
+        class VirtualDisk < Disk
+          # This object emulates Ruby's builtin Pathname object but uses a virtual file system instead of the real local
+          # one.
+          class VirtualPathname
+            SEPARATOR = File::SEPARATOR
+            # see: https://ruby-doc.org/stdlib-3.1.1/libdoc/pathname/rdoc/Pathname.html
+            STAT_METHODS = %i[
+              atime
+              birthtime
+              blockdev?
+              chardev?
+              ctime
+              directory?
+              executable?
+              file?
+              ftype
+              grpowned?
+              mtime
+              owned?
+              pipe?
+              readable?
+              setgid?
+              setuid?
+              size
+              socket?
+              sticky?
+              symlink?
+              world_readable?
+              world_writable?
+              writable?
+              zero?
+            ]
+            private_constant :STAT_METHODS
+
+            attr_accessor :virtual_disk
+
+            # @param [Hash] disk The mapping of paths to objects representing the virtual file system.
+            # @param [String] path The path of this entry.
+            # @param [Boolean] exist? Whether or not this entry represents an existing entry in the virtual file system.
+            # @param [File::Stat] stat An explicit stat that represents this object. A default VirtualStat will be
+            #   created unless specified.
+            def initialize(disk, path, **kwargs)
+              @virtual_disk = disk
+              @path = path
+
+              if kwargs.fetch(:exist?, true)
+                if kwargs[:stat]
+                  if kwargs[:stat].is_a?(Hash)
+                    @stat = VirtualStat.new(**kwargs[:stat])
+                  else
+                    @stat = kwargs[:stat]
+                  end
+                else
+                  @stat = VirtualStat.new
+                end
+              else
+                raise ArgumentError.new('can not specify a stat object when exist? is false') if kwargs[:stat]
+                @stat = nil
+              end
+            end
+
+            def ==(other)
+              other.is_a?(self.class) && other.to_s == to_s
+            end
+
+            def <=>(other)
+              to_s <=> other.to_s
+            end
+
+            def exist?
+              !@stat.nil?
+            rescue Errno::ENOENT
+              false
+            end
+
+            def stat
+              raise Errno::ENOENT.new('No such file or directory') unless exist? && (@stat.file? || @stat.directory?)
+
+              @stat
+            end
+
+            def join(other)
+              # per the docs this Pathname#join doesn't touch the file system
+              # see: https://ruby-doc.org/stdlib-3.1.1/libdoc/pathname/rdoc/Pathname.html#class-Pathname-label-Core+methods
+              lookup_or_create(Pathname.new(to_s).join(other).to_s)
+            end
+
+            alias :+ :join
+            alias :/ :join
+
+            def to_s
+              @path
+            end
+
+            def absolute?
+              to_s.start_with?(SEPARATOR)
+            end
+
+            def relative?
+              !absolute?
+            end
+
+            def basename
+              lookup_or_create(self.class.basename(to_s))
+            end
+
+            def self.basename(*args)
+              File.basename(*args)
+            end
+
+            def dirname
+              lookup_or_create(self.class.dirname(to_s))
+            end
+
+            def self.dirname(*args)
+              File.dirname(*args)
+            end
+
+            def extname
+              File.extname(to_s)
+            end
+
+            def split
+              [dirname, basename]
+            end
+
+            alias :parent :dirname
+
+            def children(with_directory=true)
+              raise Errno::ENOTDIR.new("Not a directory @ dir_initialize - #{to_s}") unless directory?
+
+              @virtual_disk.each_value.select { |dent| dent.dirname == self && dent != self }.map { |dent| with_directory ? dent : dent.basename }
+            end
+
+            def entries
+              children(false)
+            end
+
+            def cleanpath(consider_symlink=false)
+              lookup_or_create(self.class.cleanpath(to_s), stat: (exist? ? stat : nil))
+            end
+
+            def self.cleanpath(path)
+              # per the docs this Pathname#cleanpath doesn't touch the file system
+              # see: https://ruby-doc.org/stdlib-3.1.1/libdoc/pathname/rdoc/Pathname.html#class-Pathname-label-Core+methods
+              Pathname.new(path).cleanpath.to_s
+            end
+
+            private
+
+            # Check the virtual file system to see if the entry exists. Return it if it does, otherwise create a new
+            # entry representing a non-existent path.
+            #
+            # @param [String] path The path to lookup in the virtual file system. It will be normalized using #cleanpath.
+            # @return [Pathname] The path object representing the specified string.
+            def lookup_or_create(path, **kwargs)
+              existing = @virtual_disk[self.class.cleanpath(path)]
+              return existing if existing
+
+              kwargs[:exist?] = false
+              VirtualPathname.new(@virtual_disk, path, **kwargs)
+            end
+
+            def method_missing(symbol, *args)
+              # should we forward to one of the stat methods
+              if STAT_METHODS.include?(symbol)
+                # if we have a stat object then forward it
+                return stat.send(symbol, *args) if exist?
+                # if we don't have a stat object, emulate what Pathname does when it does not exist
+
+                # these two methods return nil
+                return nil if %i[ world_readable? world_writable? ].include?(symbol)
+
+                # any of the other ?-suffixed methods return false
+                return false if symbol.to_s.end_with?('?')
+
+                # any other method raises a Errno::ENOENT exception
+                raise Errno::ENOENT.new('No such file or directory')
+              end
+
+              raise NoMethodError, "undefined method `#{symbol}' for #{self.class}"
+            end
+
+            def respond_to_missing?(symbol, include_private = false)
+              STAT_METHODS.include?(symbol)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smb/server/share/provider/virtual_disk/virtual_stat.rb

@@ -0,0 +1,175 @@
+module RubySMB
+  class Server
+    module Share
+      module Provider
+        class VirtualDisk < Disk
+          # This object emulates Ruby's builtin File::Stat object but uses a virtual file system instead of the real
+          # local one. The current implementation is limited to only representing directories and standard files. All
+          # attributes are read-only and once the object is created, it is immutable.
+          class VirtualStat
+
+            # All of the keyword arguments are the keys of the attributes to set. The names are left as is, maintaining
+            # a direct 1 to 1 relationship. See the Ruby docs for File::Stat
+            # (https://ruby-doc.org/core-3.0.2/File/Stat.html) for a list of all the attributes that can be set. Some
+            # values are calculated based on others such as the mode readable? being calculated based on the mode.
+            def initialize(**kwargs)
+              # directory and file both default to being the opposite of each other, one or both can be specified
+              # but they can not both be true at the same time
+              is_dir = !!kwargs.fetch(:directory?, !kwargs.fetch(:file?, false)) # defaults to not file which defaults to false
+              is_fil = !!kwargs.fetch(:file?, !kwargs.fetch(:directory?, true)) # defaults to not directory which defaults to true
+              raise ArgumentError.new('must be either a file or a directory') unless is_dir ^ is_fil
+
+              @values = kwargs.dup
+              # the default is a directory
+              @values[:directory?] = !@values.delete(:file?) if @values.key?(:file?) # normalize on directory? if file? was specified.
+
+              @birthtime = kwargs[:birthtime] || Time.now
+            end
+
+            def blksize
+              @values.fetch(:blksize, 4096)
+            end
+
+            def blockdev?
+              false
+            end
+
+            def blocks
+              @values.fetch(:blocks, 0)
+            end
+
+            def chardev?
+              false
+            end
+
+            def pipe?
+              false
+            end
+
+            def socket?
+              false
+            end
+
+            def symlink?
+              false
+            end
+
+            def directory?
+              @values.fetch(:directory?, true)
+            end
+
+            def file?
+              !directory?
+            end
+
+            def ftype
+              raise Errno::ENOENT.new('No such file or directory') unless file? || directory?
+
+              file? ? 'file' : 'directory'
+            end
+
+            def size
+              @values.fetch(:size, 0)
+            end
+
+            def zero?
+              file? && size == 0
+            end
+
+            def nlink
+              @values.fetch(:nlink, 0)
+            end
+
+            def dev
+              @values[:dev] ||= rand(1..0xfe)
+            end
+
+            def ino
+              @values[:ino] ||= rand(1..0xfffe)
+            end
+
+            def gid
+              @values.fetch(:gid, Process.gid)
+            end
+
+            def grpowned?
+              gid == Process.gid
+            end
+
+            def uid
+              @values.fetch(:uid, Process.uid)
+            end
+
+            def owned?
+              uid == Process.uid
+            end
+
+            # last access time
+            def atime
+              @values.fetch(:atime, @birthtime)
+            end
+
+            # modification time
+            def mtime
+              @values.fetch(:mtime, @birthtime)
+            end
+
+            # change time
+            def ctime
+              @values.fetch(:ctime, @birthtime)
+            end
+
+            # the permission bits, normalized based on the standard GNU representation,
+            # see: https://www.gnu.org/software/libc/manual/html_node/Permission-Bits.html
+            def mode
+              @values.fetch(:mode, (file? ? 0o644 : 0o755))
+            end
+
+            def setuid?
+              mode & 0o04000 != 0
+            end
+
+            def setgid?
+              mode & 0o02000 != 0
+            end
+
+            def sticky?
+              mode & 0o01000 != 0
+            end
+
+            def readable?
+              return true if owned? && (mode & 1 << 8 != 0)
+              return true if grpowned? && (mode & 1 << 5 != 0)
+              return true if world_readable?
+              return false
+            end
+
+            def world_readable?
+              mode & 1 << 2 != 0
+            end
+
+            def writable?
+              return true if owned? && (mode & 1 << 7 != 0)
+              return true if grpowned? && (mode & 1 << 4 != 0)
+              return true if world_writable?
+              return false
+            end
+
+            def world_writable?
+              mode & 1 << 1 != 0
+            end
+
+            def executable?
+              return true if owned? && (mode & 1 << 6 != 0)
+              return true if grpowned? && (mode & 1 << 3 != 0)
+              return true if mode & 1 != 0
+              return false
+            end
+
+            attr_reader :birthtime
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+require 'ruby_smb/server/share/provider/disk'
+require 'ruby_smb/server/share/provider/virtual_disk/virtual_file'
+require 'ruby_smb/server/share/provider/virtual_disk/virtual_pathname'
+require 'ruby_smb/server/share/provider/virtual_disk/virtual_stat'
+
+module RubySMB
+  class Server
+    module Share
+      module Provider
+        # This is a share provider that exposes a virtual file system whose entries do not exist on disk.
+        # @since 3.1.1
+        class VirtualDisk < Disk
+          HASH_METHODS = %i[ [] each each_key each_value keys length values ]
+          private_constant :HASH_METHODS
+
+          # @param [String] name The name of this share.
+          def initialize(name)
+            @vfs = {}
+            super(name, add(VirtualPathname.new(self, File::SEPARATOR)))
+          end
+
+          # Add a dynamic file to the virtual file system. A dynamic file is one whose contents are generated by the
+          # specified block. The contents are generated when the share is opened.
+          #
+          # @param [String] path The path of the file to add, relative to the share root.
+          # @param [File::Stat] stat An explicit stat object describing the file.
+          # @yield The content generation routine.
+          # @yieldreturn [String] The generated file content.
+          def add_dynamic_file(path, stat: nil, &block)
+            raise ArgumentError.new('a block must be specified for dynamic files') unless block_given?
+            path = VirtualPathname.cleanpath(path)
+            path = File::SEPARATOR + path unless path.start_with?(File::SEPARATOR)
+            raise ArgumentError.new('must be a file') if stat && !stat.file?
+
+            vf = VirtualDynamicFile.new(self, path, stat: stat, &block)
+            add(vf)
+          end
+
+          # Add a mapped file to the virtual file system. A mapped file is one who is backed by an entry on
+          # disk. The path need not be present, but if it does exist, it must be a file.
+          #
+          # @param [String] path The path of the file to add, relative to the share root.
+          # @param [String, Pathname] mapped_path The path on the local file system to map into the virtual file system.
+          def add_mapped_file(path, mapped_path)
+            path = VirtualPathname.cleanpath(path)
+            path = File::SEPARATOR + path unless path.start_with?(File::SEPARATOR)
+
+            vf = VirtualMappedFile.new(self, path, mapped_path)
+            add(vf)
+          end
+
+          # Add a static file to the virtual file system. A static file is one whose contents are known at creation time
+          # and do not change. If *content* is a file-like object that responds to #read, the data will be read using
+          # that method. Likewise, if *content* has a #stat attribute and *stat* was not specified, then the value of
+          # content's #stat attribute will be used.
+          #
+          # @param [String] path The path of the file to add, relative to the share root.
+          # @param [String, #read, #stat] content The static content to add.
+          # @param [File::Stat] stat An explicit stat object describing the file.
+          def add_static_file(path, content, stat: nil)
+            path = VirtualPathname.cleanpath(path)
+            path = File::SEPARATOR + path unless path.start_with?(File::SEPARATOR)
+            raise ArgumentError.new('must be a file') if stat && !stat.file?
+
+            stat = content.stat if content.respond_to?(:stat) && stat.nil?
+            content = content.read if content.respond_to?(:read)
+            vf = VirtualStaticFile.new(self, path, content, stat: stat)
+            add(vf)
+          end
+
+          def add(virtual_pathname)
+            raise ArgumentError.new('paths must be absolute') unless virtual_pathname.absolute?
+
+            path = virtual_pathname.to_s
+            raise ArgumentError.new('paths must be normalized') unless VirtualPathname.cleanpath(path) == path
+
+            path_parts = path.split(VirtualPathname::SEPARATOR)
+            2.upto(path_parts.length - 1) do |idx|
+              ancestor = path_parts[0...idx].join(path[VirtualPathname::SEPARATOR])
+              next if @vfs[ancestor]&.directory?
+
+              @vfs[ancestor] = VirtualPathname.new(self, ancestor, stat: VirtualStat.new(directory?: true))
+            end
+
+            @vfs[path] = virtual_pathname
+          end
+
+          def new_processor(server_client, session)
+            scoped_virtual_disk = self.class.new(@name)
+            @vfs.each_value do |path|
+              path = path.dup
+              path.virtual_disk = scoped_virtual_disk if path.is_a?(VirtualPathname)
+              path = path.generate(server_client, session) if path.is_a?(VirtualDynamicFile)
+              scoped_virtual_disk.add(path)
+            end
+            self.class::Processor.new(scoped_virtual_disk, server_client, session)
+          end
+
+          private
+
+          def method_missing(symbol, *args)
+            if HASH_METHODS.include?(symbol)
+              return @vfs.send(symbol, *args)
+            end
+
+            raise NoMethodError, "undefined method `#{symbol}' for #{self.class}"
+          end
+
+          def respond_to_missing?(symbol, include_private = false)
+            HASH_METHODS.include?(symbol)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -36,3 +36,4 @@ end
 
 require 'ruby_smb/server/share/provider/disk'
 require 'ruby_smb/server/share/provider/pipe'
+require 'ruby_smb/server/share/provider/virtual_disk'

data/lib/ruby_smb/server.rb

@@ -14,8 +14,10 @@ module RubySMB
     Connection = Struct.new(:client, :thread)
 
     # @param server_sock the socket on which the server should listen
-    # @param [Gss::Provider] the authentication provider
-    def initialize(server_sock: nil, gss_provider: nil, logger: nil)
+    # @param [Gss::Provider] gss_provider the authentication provider
+    # @param [::Logger] logger the logger to use for diagnostic messages
+    # @param thread_factory a block to create threads for serving clients
+    def initialize(server_sock: nil, gss_provider: nil, logger: nil, thread_factory: nil)
       server_sock = ::TCPServer.new(445) if server_sock.nil?
 
       @guid = Random.new.bytes(16)
@@ -36,6 +38,14 @@ module RubySMB
         @logger = logger
       end
 
+      if thread_factory.nil?
+        # the default thread factory uses Ruby's standard Thread#new
+        thread_factory = Proc.new do |_server_client, &block|
+          Thread.new(&block)
+        end
+      end
+      @thread_factory = thread_factory
+
       # share name => provider instance
       @shares = {
         'IPC$' => Share::Provider::IpcPipe.new
@@ -53,7 +63,7 @@ module RubySMB
       loop do
         sock = @socket.accept
         server_client = ServerClient.new(self, RubySMB::Dispatcher::Socket.new(sock, read_timeout: nil))
-        @connections << Connection.new(server_client, Thread.new { server_client.run })
+        @connections << Connection.new(server_client, @thread_factory.call(server_client) { server_client.run })
 
         break unless block.nil? || block.call(server_client)
       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

data/lib/ruby_smb/smb1/packet/nt_create_andx_request.rb

@@ -47,7 +47,17 @@ module RubySMB
 
         # Represents the specific layout of the DataBlock for a {NtCreateAndxRequest} Packet.
         class DataBlock < RubySMB::SMB1::DataBlock
-          string :file_name, label: 'File Name'
+          uint8  :pad,  label: 'Pad',  onlyif: :has_padding?
+          choice :file_name, selection: -> { parent.smb_header.flags2.unicode } do
+            stringz   0
+            stringz16 1
+          end
+
+          # This method checks if the optional pad field is present.
+          def has_padding?
+            parent.smb_header.flags2.unicode == 1 && pad.abs_offset % 2 == 1
+          end
+          private :has_padding?
         end
 
         smb_header        :smb_header

data/lib/ruby_smb/smb1/packet/nt_trans/create_request.rb

@@ -57,7 +57,7 @@ module RubySMB
             end
           end
 
-          # The Trans2 Data Blcok for this particular Subcommand
+          # The Trans2 Data Block for this particular Subcommand
           class Trans2Data < BinData::Record
             security_descriptor :security_descriptor
             file_full_ea_info   :extended_attributes

data/lib/ruby_smb/smb1/packet/read_andx_response.rb

@@ -22,13 +22,14 @@ module RubySMB
 
         # Represents the specific layout of the DataBlock for a {ReadAndxResponse} Packet.
         class DataBlock < RubySMB::SMB1::DataBlock
-          uint8  :pad,  label: 'Pad',  onlyif: -> { has_padding? }
+          uint8  :pad,  label: 'Pad',  onlyif: :has_padding?
           string :data, label: 'Data', read_length: -> { parent.parameter_block.data_length }
 
-          # This method checks if the optional pad field is present in the response.
+          # This method checks if the optional pad field is present.
           def has_padding?
-            return false if byte_count.zero?
-            return true if byte_count - parent.parameter_block.data_length == 1
+            bc = byte_count.clear? ? 0 : byte_count  # work around infinite recursion
+            return false if bc == 0
+            return true if bc - parent.parameter_block.data_length == 1
             false
           end
           private :has_padding?

data/lib/ruby_smb/smb1/packet/session_setup_request.rb

@@ -23,9 +23,17 @@ module RubySMB
         # for the security blob, you must null-terminate the {native_os} and {native_lan_man} fields
         # yourself if you set them away from their defaults.
         class DataBlock < RubySMB::SMB1::DataBlock
-          string      :security_blob,  label: 'Security Blob (GSS-API)', length: -> { parent.parameter_block.security_blob_length }
-          string      :native_os,      label: 'Native OS',             initial_value: "Windows 7 Ultimate N 7601 Service Pack 1\x00"
-          string      :native_lan_man, label: 'Native LAN Manager',    initial_value: "Windows 7 Ultimate N 6.1\x00"
+          string      :security_blob,  label: 'Security Blob (GSS-API)', read_length: -> { parent.parameter_block.security_blob_length }
+          uint8       :pad1,           label: 'Pad 1', onlyif: -> { parent.smb_header.flags2.unicode == 1 && pad1.abs_offset % 2 == 1 }
+          choice      :native_os,      label: 'Native OS', selection: -> { parent.smb_header.flags2.unicode } do
+            stringz   0, initial_value: 'Windows 7 Ultimate N 7601 Service Pack 1'
+            stringz16 1, initial_value: 'Windows 7 Ultimate N 7601 Service Pack 1'.encode('utf-16le')
+          end
+          uint8       :pad2,           label: 'Pad 2', onlyif: -> { parent.smb_header.flags2.unicode == 1 && pad2.abs_offset % 2 == 1 }
+          choice      :native_lan_man, label: 'Native LAN Manager', selection: -> { parent.smb_header.flags2.unicode } do
+            stringz   0, initial_value: 'Windows 7 Ultimate N 6.1'
+            stringz16 1, initial_value: 'Windows 7 Ultimate N 6.1'.encode('utf-16le')
+          end
         end
 
         smb_header        :smb_header
@@ -34,7 +42,7 @@ module RubySMB
 
         # Takes an NTLM Type 1 Message and creates the GSS Security Blob
         # for it and sets it in the {RubySMB::SMB1::Packet::SessionSetupRequest::DataBlock#security_blob}
-        # field. It also automaticaly sets the length in
+        # field. It also automatically sets the length in
         # {RubySMB::SMB1::Packet::SessionSetupRequest::ParameterBlock#security_blob_length}
         #
         # @param type1_message [String] the serialized Type 1 NTLM message

data/lib/ruby_smb/smb1/packet/trans2/data_block.rb

@@ -35,13 +35,21 @@ module RubySMB
           # Determines the correct length for the padding in front of
           # #trans2_data. It should always force a 4-byte alignment.
           def pad2_length
-            if enable_padding
+            if enable_padding && (trans2_data.num_bytes > 0 || (!byte_count.clear? && offset_of(pad2) - byte_count.num_bytes < byte_count))
               offset = (trans2_parameters.abs_offset + trans2_parameters.length) % 4
               (4 - offset) % 4
             else
               0
             end
           end
+
+          # Some structures use an opaque buffer in trans2_data. Calculate its
+          # size here.
+          def buffer_read_length
+            return 0 if byte_count.clear?
+
+            byte_count + byte_count.num_bytes - offset_of(trans2_data)
+          end
         end
       end
     end