ruby_smb 3.1.1 → 3.1.4

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

@@ -1,3 +1,4 @@
+require 'zlib'
 require 'ruby_smb/server/share/provider/processor'
 
 module RubySMB
@@ -16,7 +17,7 @@ module RubySMB
             include RubySMB::Server::Share::Provider::Disk::Processor::Query
             include RubySMB::Server::Share::Provider::Disk::Processor::Read
 
-            Handle = Struct.new(:remote_path, :local_path, :durable?)
+            Handle = Struct.new(:remote_path, :local_path, :durable?, :file)
             def initialize(provider, server_client, session)
               super
               @handles = {}
@@ -30,6 +31,25 @@ module RubySMB
               )
             end
 
+            # Build an access mask bit field for the specified path. The return type is a DirectoryAccessMask if path
+            # is a directory, otherwise it's a FileAccessMask.
+            #
+            # @param Pathname path the path to build an access mask for
+            # @return [DirectoryAccessMask, FileAccessMask] the access mask
+            def smb2_access_mask(path)
+              # see: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/b3af3aaf-9271-4419-b326-eba0341df7d2
+              if path.directory?
+                am = SMB2::BitField::DirectoryAccessMask.new
+                am.traverse = true
+                am.list = true
+              else
+                am = SMB2::BitField::FileAccessMask.new
+                am.read_data = true
+              end
+              am.read_attr = true
+              am
+            end
+
             private
 
             def build_fscc_file_attributes(path)
@@ -44,6 +64,29 @@ module RubySMB
 
             def build_fscc_file_information(path, info_class, rename: nil)
               case info_class
+              when Fscc::FileInformation::FILE_ACCESS_INFORMATION
+                info = Fscc::FileInformation::FileAccessInformation.new
+                # smb2_access_mask returns back either file or directory access mask depending on what path is,
+                # FileAccessInformation however isn't defined to account for this context so set it from the binary
+                # value
+                info.access_flags.read(smb2_access_mask(path).to_binary_s)
+              when Fscc::FileInformation::FILE_ALIGNMENT_INFORMATION
+                info = Fscc::FileInformation::FileAlignmentInformation.new
+              when Fscc::FileInformation::FILE_ALL_INFORMATION
+                info = Fscc::FileInformation::FileAllInformation.new
+                info.basic_information = build_fscc_file_information(path, Fscc::FileInformation::FILE_BASIC_INFORMATION, rename: rename)
+                info.standard_information = build_fscc_file_information(path, Fscc::FileInformation::FILE_STANDARD_INFORMATION, rename: rename)
+                info.internal_information = build_fscc_file_information(path, Fscc::FileInformation::FILE_INTERNAL_INFORMATION, rename: rename)
+                info.ea_information = build_fscc_file_information(path, Fscc::FileInformation::FILE_EA_INFORMATION, rename: rename)
+                info.access_information = build_fscc_file_information(path, Fscc::FileInformation::FILE_ACCESS_INFORMATION, rename: rename)
+                info.position_information = build_fscc_file_information(path, Fscc::FileInformation::FILE_POSITION_INFORMATION, rename: rename)
+                info.mode_information = build_fscc_file_information(path, Fscc::FileInformation::FILE_MODE_INFORMATION, rename: rename)
+                info.alignment_information = build_fscc_file_information(path, Fscc::FileInformation::FILE_ALIGNMENT_INFORMATION, rename: rename)
+                info.name_information = build_fscc_file_information(path, Fscc::FileInformation::FILE_NAME_INFORMATION, rename: rename)
+              when Fscc::FileInformation::FILE_BASIC_INFORMATION
+                info = Fscc::FileInformation::FileBasicInformation.new
+                set_common_timestamps(info, path)
+                info.file_attributes = build_fscc_file_attributes(path)
               when Fscc::FileInformation::FILE_EA_INFORMATION
                 info = Fscc::FileInformation::FileEaInformation.new
               when Fscc::FileInformation::FILE_FULL_DIRECTORY_INFORMATION
@@ -54,21 +97,42 @@ module RubySMB
                 info = Fscc::FileInformation::FileIdBothDirectoryInformation.new
                 set_common_info(info, path)
                 info.file_name = rename || path.basename.to_s
+              when Fscc::FileInformation::FILE_ID_FULL_DIRECTORY_INFORMATION
+                info = Fscc::FileInformation::FileIdFullDirectoryInformation.new
+                set_common_info(info, path)
+                info.file_name = rename || path.basename.to_s
+              when Fscc::FileInformation::FILE_INTERNAL_INFORMATION
+                info = Fscc::FileInformation::FileInternalInformation.new
+                info.file_id = Zlib::crc32(path.to_s)
+              when Fscc::FileInformation::FILE_MODE_INFORMATION
+                info = Fscc::FileInformation::FileModeInformation.new
+              when Fscc::FileInformation::FILE_NAME_INFORMATION
+                info = Fscc::FileInformation::FileNameInformation.new
+                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_POSITION_INFORMATION
+                info = Fscc::FileInformation::FilePositionInformation.new
+                info.current_byte_offset = path.size
+              when Fscc::FileInformation::FILE_STANDARD_INFORMATION
+                info = Fscc::FileInformation::FileStandardInformation.new
+                info.allocation_size = get_allocation_size(path)
+                info.end_of_file = path.size
+                info.directory = path.directory? ? 1 : 0
               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'
-                  )
+                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)})"
+                logger.warn("Unsupported FSCC file information class: #{info_class} (#{Fscc::FileInformation.name(info_class)})")
+                raise NotImplementedError
               end
 
               # some have a next offset field that needs to be set accordingly
@@ -96,7 +160,7 @@ module RubySMB
                 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 + '/')
+                unless local_path == provider.path || local_path.to_s.start_with?(provider.path.to_s.delete_suffix(File::SEPARATOR) + File::SEPARATOR)
                   raise RuntimeError, "Directory traversal detected to: #{local_path}"
                 end
               else

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

@@ -5,14 +5,20 @@ module RubySMB
   class Server
     module Share
       module Provider
+        # This is a share provider that exposes the local file system.
         class Disk < Base
           TYPE = TYPE_DISK
           # emulate NTFS just like Samba does
           FILE_SYSTEM = FileSystem::NTFS
 
+          # @param [String] name The name of this share.
+          # @param [String, Pathname] path The local file system path to share. This path must be an absolute path to an existing
+          #   directory.
           def initialize(name, path)
-            path = Pathname.new(File.expand_path(path))
-            raise ArgumentError unless path.directory?
+            path = Pathname.new(File.expand_path(path)) if path.is_a?(String)
+            raise ArgumentError.new('path must be a directory') unless path.directory? # it needs to exist
+            raise ArgumentError.new('path must be absolute') unless path.absolute? # it needs to be absolute so it is independent of the cwd
+
             @path = path
             super(name)
           end

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

@@ -0,0 +1,85 @@
+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
+        class VirtualDisk < Disk
+          # A dynamic file is one whose contents are generated by the specified
+          # block.
+          class VirtualDynamicFile < VirtualPathname
+            # @param [Hash] disk The mapping of paths to objects representing the virtual file system.
+            # @param [String] path The path of this entry.
+            # @param [File::Stat] stat An explicit stat object describing the file.
+            def initialize(disk, path, stat: nil, &block)
+              raise ArgumentError.new('a generation block must be specified') if block.nil?
+
+              @content_generator = block
+              super(disk, path)
+              @stat = stat
+            end
+
+            def generate(server_client, session)
+              content = @content_generator.call(server_client, session)
+              VirtualStaticFile.new(@virtual_disk, @path, content, stat: @stat)
+            end
+          end
+
+          # A static file is one whose contents are known at creation time and
+          # do not change.
+          class VirtualStaticFile < VirtualPathname
+            # @param [Hash] disk The mapping of paths to objects representing the virtual file system.
+            # @param [String] path The path of this entry.
+            # @param [String] content The static content of this file.
+            # @param [File::Stat] stat An explicit stat object describing the file.
+            def initialize(disk, path, content, stat: nil)
+              stat = stat || VirtualStat.new(file?: true, size: content.size)
+              raise ArgumentError.new('stat is not a file') unless stat.file?
+
+              @content = content
+              super(disk, path, stat: stat)
+            end
+
+            def open(mode = 'r', &block)
+              file = StringIO.new(@content)
+              block_given? ? block.call(file) : file
+            end
+
+            attr_reader :content
+          end
+
+          # 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.
+          class VirtualMappedFile < VirtualPathname
+            # @param [Hash] disk The mapping of paths to objects representing the virtual file system.
+            # @param [String] path The path of this entry.
+            # @param [String, Pathname] mapped_path The path on the local file system to map into the virtual file system.
+            def initialize(disk, path, mapped_path)
+              mapped_path = Pathname.new(File.expand_path(mapped_path)) if mapped_path.is_a?(String)
+              raise ArgumentError.new('mapped_path must be absolute') unless mapped_path.absolute? # it needs to be absolute so it is independent of the cwd
+
+              @virtual_disk = disk
+              @path = path
+              @mapped_path = mapped_path
+            end
+
+            def exist?
+              # filter out anything that's not a directory but allow the file to be missing, this prevents exposing
+              # directories which could yield path confusion errors
+              @mapped_path.exist? && @mapped_path.file?
+            end
+
+            def stat
+              @mapped_path.stat
+            end
+
+            def open(mode = 'r', &block)
+              @mapped_path.open(mode, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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