rex-core 0.1.34 → 0.1.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6710f1bd644f60c0caf4796979be01791425c0d5a2092105e9038debd835ea9a
-  data.tar.gz: 1b1631796274f047cc79c502423bfee9e6dea5b0d0cf29e82ce82521bd07d25e
+  metadata.gz: 722c1d73aa2712e77940801d1f02e44565e0234944e7c50d8d82f6db845bce0f
+  data.tar.gz: 295ecbe54da2c7b54f6f19b7c8676140fcb2f18dcc660eaedfef7aa3c5633b9a
 SHA512:
-  metadata.gz: 0fab85212fe9d2148d61e07640d33d28b39a0b0beedb2684efa0ac119f336f03c2248eddceba6dd9c310f98c50585393ccd3ebebb79471c7f35c52c2215617d6
-  data.tar.gz: 7b499c51ead53b5e0acd7e15e6f0cdc94d988f96a37f2bb38c02b3f6a5877bf72ee5aabcfc3d69cbcccf53745a6a9737961dfb1c59c51badfe67adb1cfcd6226
+  metadata.gz: e2e5510ad24f1770fb127efd2cee8b0b08653be57eb15b7c44e51ef03a1fc6d23c5636259c632544a1d7ed17fa08dca289ee2dc3161c730803ab852a63ec677f
+  data.tar.gz: a5998d868389e099d9108dcdf9a4f86d0e91b6053f2cc3cb2fea75e84e3f5ddfa86136d018f70cd150817e86d12a455f4bce9ddcf0794f1ab512a64c606c4f40

data/lib/rex/core/version.rb

@@ -1,5 +1,5 @@
 module Rex
   module Core
-    VERSION = "0.1.34"
+    VERSION = "0.1.35"
   end
 end

data/lib/rex/io/fiber_scheduler.rb

@@ -0,0 +1,156 @@
+require 'fiber'
+require 'io/nonblock'
+require 'rex/compat'
+
+module Rex
+module IO
+
+  # This fiber scheduler is heavily base on
+  # https://blog.monotone.dev/ruby/2020/12/25/ruby-3-fiber.html
+  class FiberScheduler
+    def initialize
+      @readable = {}
+      @writable = {}
+      @waiting = {}
+      @ready = []
+      @pending = []
+      @blocking = 0
+      @urgent = Rex::Compat.pipe
+      @mutex = Mutex.new
+    end
+
+    # This allows the fiber to be scheduled in the #run thread from another thread
+    def schedule_fiber(&block)
+      @mutex.synchronize do
+        @pending << block
+      end
+      # Wake up the scheduler
+      @urgent.last.write_nonblock('.') rescue nil
+    end
+
+    def run
+      while @readable.any? or @writable.any? or @waiting.any? or @blocking.positive? or @ready.any? or @pending.any?
+        # Start any pending fibers
+        pending_blocks = []
+        @mutex.synchronize do
+          pending_blocks = @pending.dup
+          @pending.clear
+        end
+
+        pending_blocks.each do |block|
+          fiber = Fiber.new(blocking: false, &block)
+          fiber.resume
+        end
+
+        begin
+          readable, writable = ::IO.select(@readable.keys + [@urgent.first], @writable.keys, [], 0.1)
+        rescue ::IOError
+          cleanup_closed_ios
+          next
+        end
+
+        # Drain the urgent pipe
+        if readable&.include?(@urgent.first)
+          @urgent.first.read_nonblock(1024) rescue nil
+        end
+
+        readable&.each do |io|
+          next if io == @urgent.first
+
+          if fiber = @readable.delete(io)
+            fiber.resume
+          end
+        end
+
+        writable&.each do |io|
+          if fiber = @writable.delete(io)
+            fiber.resume
+          end
+        end
+
+        @waiting.keys.each do |fiber|
+          if current_time > @waiting[fiber]
+            @waiting.delete(fiber)
+            fiber.resume
+          end
+        end
+
+        ready, @ready = @ready, []
+        ready.each do |fiber|
+          fiber.resume
+        end
+      end
+    end
+
+    def io_wait(io, events, timeout)
+      unless (events & ::IO::READABLE).zero?
+        @readable[io] = Fiber.current
+      end
+      unless (events & ::IO::WRITABLE).zero?
+        @writable[io] = Fiber.current
+      end
+
+      Fiber.yield
+      events
+    end
+
+    def kernel_sleep(duration = nil)
+      block(:sleep, duration)
+      true
+    end
+
+    def block(blocker, timeout = nil)
+      if timeout
+        @waiting[Fiber.current] = current_time + timeout
+        begin
+          Fiber.yield
+        ensure
+          @waiting.delete(Fiber.current)
+        end
+      else
+        @blocking += 1
+        begin
+          Fiber.yield
+        ensure
+          @blocking -= 1
+        end
+      end
+    end
+
+    def unblock(blocker, fiber)
+      @ready << fiber
+      io = @urgent.last
+      io.write_nonblock('.')
+    end
+
+    def close
+      run
+      @urgent.each(&:close)
+      @urgent = nil
+    end
+
+    def closed?
+      @urgent.nil?
+    end
+
+    def fiber(&block)
+      fiber = Fiber.new(blocking: false, &block)
+      fiber.resume
+      fiber
+    end
+
+    private
+
+    def current_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def cleanup_closed_ios
+      @readable.delete_if { |io, _| io.closed? rescue true }
+      @writable.delete_if { |io, _| io.closed? rescue true }
+      @waiting.delete_if { |fiber, _| !fiber || !fiber.alive? rescue true }
+    end
+  end
+
+end
+end

data/lib/rex/io/relay_manager.rb

@@ -0,0 +1,113 @@
+require 'rex/io/fiber_scheduler'
+
+module Rex
+module IO
+
+# An IO RelayManager which will read data from a socket and write it to a sink
+# using a background thread.
+class RelayManager
+  attr_reader :thread
+
+  def initialize
+    @thread = nil
+    @scheduler = FiberScheduler.new
+  end
+
+  # Add a IO relay to the manager. This will start relaying data from the source
+  # socket to the destination sink immediately. An optional "on_exit" callback
+  # can be provided which will be called when the socket is closed.
+  #
+  # @param sock [::Socket] The source socket that data will be read from.
+  # @param sink [#write, #call] A data destination where read data will be sent. It is called
+  #   with one parameter, the data to be transferred. If the object exposes a #write method, it will
+  #   be called repeatedly all data is processed and the return value will be used to determine how
+  #   much of the data was written. If the object exposes a #call method, it will be called once and
+  #   must handle processing all the data it is provided.
+  # @param name [String] A human-friendly name for the relay used in debug output.
+  # @param on_exit [#call] A callback to be invoked when sink can no longer be read from.
+  def add_relay(sock, sink: nil, name: nil, on_exit: nil)
+    @scheduler.schedule_fiber do
+      relay_fiber(sock, sink, name, on_exit: on_exit)
+    end
+
+    start unless running?
+  end
+
+  # Write all data to the specified IO. This is intended to be used in scenarios
+  # where partial writes are possible but not desirable.
+  #
+  # @param io [#write] An object to write the data to. It must return a number indicating
+  #   how many bytes of the provided data were processed.
+  # @param data [String] The data that should be written.
+  def self.io_write_all(io, data)
+    offset = 0
+    while offset < data.bytesize
+      written = io.write(data.byteslice(offset..-1))
+      offset += written
+    end
+    data.bytesize
+  end
+
+  private
+
+  def running?
+    @thread && @thread.alive?
+  end
+
+  def start
+    return false if running?
+
+    @thread = Thread.new { run }
+    true
+  end
+
+  def run
+    old_scheduler = Fiber.scheduler
+    # A fiber scheduler can be set per-thread
+    Fiber.set_scheduler(@scheduler)
+
+    # Run the scheduler (blocks here)
+    @scheduler.run
+  ensure
+    Fiber.set_scheduler(old_scheduler)
+  end
+
+  def relay_fiber(sock, sink, name, on_exit: nil)
+    loop do
+      break if sock.closed?
+
+      buf = sock.readpartial(32_768)
+      write_to_sink(sink, buf)
+    end
+  rescue EOFError
+    nil
+  rescue => e
+    message = "#{self.class.name}#relay_fiber(name: #{name}): #{e.class} #{e}"
+    if defined?(elog)  # elog is defined by framework, otherwise use stderr
+      elog(message, error: e)
+    else
+      $stderr.puts message
+    end
+  ensure
+    unless sock.closed?
+      sock.close rescue nil
+    end
+
+    on_exit.call if on_exit
+  end
+
+  def write_to_sink(sink, data)
+    if sink.respond_to?(:write)
+      self.class.io_write_all(sink, data)
+
+    elsif sink.respond_to?(:call)
+      sink.call(data)
+
+    else
+      raise ArgumentError, "Unsupported sink type: #{sink.inspect}"
+    end
+  end
+end
+
+end
+end

data/lib/rex/io/socket_abstraction.rb

@@ -1,7 +1,8 @@
 # -*- coding: binary -*-
 
 require 'socket'
-require 'fcntl'
+
+require 'rex/io/relay_manager'
 
 module Rex
   module IO
@@ -12,6 +13,7 @@ module Rex
     #
     ###
     module SocketAbstraction
+
       ###
       #
       # Extension information for required Stream interface.
@@ -54,7 +56,7 @@ module Rex
       def cleanup_abstraction
         lsock.close if lsock and !lsock.closed?
 
-        monitor_thread.join if monitor_thread&.alive?
+        monitor_thread.join if monitor_thread&.alive? && monitor_thread&.object_id != Thread.current.object_id
 
         rsock.close if rsock and !rsock.closed?
 
@@ -114,105 +116,27 @@ module Rex
       #
       attr_reader :rsock
 
-      module MonitoredRSock
-        def close
-          @close_requested = true
-          @monitor_thread.join
-          nil
-        end
+      protected
 
-        def sysclose
-          self.class.instance_method(:close).bind(self).call
+      def monitor_rsock(name = 'MonitorRemote')
+        if respond_to?(:close_write)
+          on_exit = method(:close_write)
+        else
+          on_exit = nil
         end
 
-        attr_reader :close_requested
-        attr_writer :monitor_thread
+        monitor_sock(rsock, sink: self, name: name, on_exit: on_exit)
       end
 
-      protected
+      def monitor_sock(sock, sink:, name:, on_exit: nil)
+        @relay_manager ||= Rex::IO::RelayManager.new
+        @relay_manager.add_relay(sock, sink: sink, name: name, on_exit: on_exit)
+      end
 
-      def monitor_rsock(threadname = 'SocketMonitorRemote')
-        rsock.extend(MonitoredRSock)
-        rsock.monitor_thread = self.monitor_thread = Rex::ThreadFactory.spawn(threadname, false) do
-          loop do
-            closed = rsock.nil? || rsock.close_requested
-
-            if closed
-              wlog('monitor_rsock: the remote socket has been closed, exiting loop')
-              break
-            end
-
-            buf = nil
-
-            begin
-              s = Rex::ThreadSafe.select([rsock], nil, nil, 0.2)
-              next if s.nil? || s[0].nil?
-            rescue Exception => e
-              wlog("monitor_rsock: exception during select: #{e.class} #{e}")
-              closed = true
-            end
-
-            unless closed
-              begin
-                buf = rsock.sysread(32_768)
-                if buf.nil?
-                  closed = true
-                  wlog('monitor_rsock: closed remote socket due to nil read')
-                end
-              rescue EOFError => e
-                closed = true
-                dlog('monitor_rsock: EOF in rsock')
-              rescue ::Exception => e
-                closed = true
-                wlog("monitor_rsock: exception during read: #{e.class} #{e}")
-              end
-            end
-
-            unless closed
-              total_sent = 0
-              total_length = buf.length
-              while total_sent < total_length
-                begin
-                  data = buf[total_sent, buf.length]
-
-                  # Note that this must be write() NOT syswrite() or put() or anything like it.
-                  # Using syswrite() breaks SSL streams.
-                  sent = write(data)
-
-                  # sf: Only remove the data off the queue is write was successful.
-                  #     This way we naturally perform a resend if a failure occurred.
-                  #     Catches an edge case with meterpreter TCP channels where remote send
-                  #     fails gracefully and a resend is required.
-                  if sent.nil?
-                    closed = true
-                    wlog('monitor_rsock: failed writing, socket must be dead')
-                    break
-                  elsif sent > 0
-                    total_sent += sent
-                  end
-                rescue ::IOError, ::EOFError => e
-                  closed = true
-                  wlog("monitor_rsock: exception during write: #{e.class} #{e}")
-                  break
-                end
-              end
-            end
-
-            next unless closed
-
-            begin
-              close_write if respond_to?('close_write')
-            rescue StandardError
-            end
-
-            break
-          end
-
-          rsock.sysclose
-        end
+      def monitor_thread
+        @relay_manager&.thread
       end
 
-      attr_accessor :monitor_thread
       attr_writer :lsock, :rsock
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rex-core
 version: !ruby/object:Gem::Version
-  version: 0.1.34
+  version: 0.1.35
 platform: ruby
 authors:
 - Metasploit Hackers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-02 00:00:00.000000000 Z
+date: 2025-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -62,6 +62,8 @@ files:
 - lib/rex/exceptions.rb
 - lib/rex/file.rb
 - lib/rex/io/datagram_abstraction.rb
+- lib/rex/io/fiber_scheduler.rb
+- lib/rex/io/relay_manager.rb
 - lib/rex/io/ring_buffer.rb
 - lib/rex/io/socket_abstraction.rb
 - lib/rex/io/stream.rb