rex-core 0.1.17 → 0.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc3a037b0e2014526adcb218da1f7519b84c59ed81457e63d3d4bfe8632b7d32
-  data.tar.gz: ac2a430d2978df81f3671123d1c192430098ab4f2b3833a26489bcbe2f6e7db9
+  metadata.gz: 1ab976e408acf491f30c2d5ec12fde516b6ceebf75257216a07997dccee92ba5
+  data.tar.gz: 382f26dd0e86f8245bdbdde3462f5555080a6f85a03b76a7a164ab4b796c7672
 SHA512:
-  metadata.gz: 0adeeff27a4a9dee8092466387624a60ff991789b419e15c667c9f0b2a94a3c8f64e836ee967182dd78834e46722c42fbb2e8cf0c1af5a2210b9bacc136da9e2
-  data.tar.gz: 308daa85d93b917ce3dbb7fc5445087269899c437baaa96ce0082901ee54de94e6e5b7016cd3cfaf4914716b0fd8bddc331c439d2cf5c9d6999572215bddfa1c
+  metadata.gz: 27ca06a5a3a339a079c2b177dbb034737e1836a2b9a14edfd48accc04912a803c8158eebc6f800425fbcbaccf86abfc22d2a7892cc4650e073927a758cf11c14
+  data.tar.gz: a4b223838152b1eb302bc3ff52298b60d9ed25f5eb9d920eb6a526607d5490f4fdaa89f8135913c15b66cbce0cf54a6be5b263faf717d299000dcc368491b6fd

data/lib/rex/core/version.rb

@@ -1,5 +1,5 @@
 module Rex
   module Core
-    VERSION = "0.1.17"
+    VERSION = "0.1.21"
   end
 end

data/lib/rex/io/socket_abstraction.rb

@@ -4,202 +4,192 @@ require 'socket'
 require 'fcntl'
 
 module Rex
-module IO
-
-###
-#
-# This class provides an abstraction to a stream based
-# connection through the use of a streaming socketpair.
-#
-###
-module SocketAbstraction
-
-  ###
-  #
-  # Extension information for required Stream interface.
-  #
-  ###
-  module Ext
-
-    #
-    # Initializes peer information.
+  module IO
+    ###
     #
-    def initinfo(peer,local)
-      @peer = peer
-      @local = local
-    end
-
+    # This class provides an abstraction to a stream based
+    # connection through the use of a streaming socketpair.
     #
-    # Symbolic peer information.
-    #
-    def peerinfo
-      (@peer || "Remote Pipe")
-    end
+    ###
+    module SocketAbstraction
+      ###
+      #
+      # Extension information for required Stream interface.
+      #
+      ###
+      module Ext
+        #
+        # Initializes peer information.
+        #
+        def initinfo(peer, local)
+          @peer = peer
+          @local = local
+        end
 
-    #
-    # Symbolic local information.
-    #
-    def localinfo
-      (@local || "Local Pipe")
-    end
-  end
-
-  #
-  # Override this method to init the abstraction
-  #
-  def initialize_abstraction
-    self.lsock, self.rsock = Rex::Compat.pipe
-  end
-
-  #
-  # This method cleans up the abstraction layer.
-  #
-  def cleanup_abstraction
-    self.lsock.close if (self.lsock and !self.lsock.closed?)
-    self.rsock.close if (self.rsock and !self.rsock.closed?)
-
-    self.lsock = nil
-    self.rsock = nil
-  end
-
-  #
-  # Low-level write to the local side.
-  #
-  def syswrite(buffer)
-    lsock.syswrite(buffer)
-  end
-
-  #
-  # Low-level read from the local side.
-  #
-  def sysread(length)
-    lsock.sysread(length)
-  end
-
-  #
-  # Shuts down the local side of the stream abstraction.
-  #
-  def shutdown(how)
-    lsock.shutdown(how)
-  end
-
-  #
-  # Closes both sides of the stream abstraction.
-  #
-  def close
-    cleanup_abstraction
-    super
-  end
-
-  #
-  # Symbolic peer information.
-  #
-  def peerinfo
-    "Remote-side of Pipe"
-  end
-
-  #
-  # Symbolic local information.
-  #
-  def localinfo
-    "Local-side of Pipe"
-  end
-
-  #
-  # The left side of the stream.
-  #
-  attr_reader :lsock
-  #
-  # The right side of the stream.
-  #
-  attr_reader :rsock
-
-protected
-
-  def monitor_rsock(threadname = "SocketMonitorRemote")
-    self.monitor_thread = Rex::ThreadFactory.spawn(threadname, false) {
-      loop do
-        closed = false
-        buf    = nil
-
-        if not self.rsock
-          wlog("monitor_rsock: the remote socket is nil, exiting loop")
-          break
+        #
+        # Symbolic peer information.
+        #
+        def peerinfo
+          (@peer || 'Remote Pipe')
         end
 
-        begin
-          s = Rex::ThreadSafe.select( [ self.rsock ], nil, nil, 0.2 )
-          if( s == nil || s[0] == nil )
-            next
-          end
-        rescue Exception => e
-          wlog("monitor_rsock: exception during select: #{e.class} #{e}")
-          closed = true
+        #
+        # Symbolic local information.
+        #
+        def localinfo
+          (@local || 'Local Pipe')
         end
+      end
 
-        if( closed == false )
-          begin
-            buf = self.rsock.sysread( 32768 )
-            if buf == nil
-              closed = true
-              wlog("monitor_rsock: closed remote socket due to nil read")
+      #
+      # Override this method to init the abstraction
+      #
+      def initialize_abstraction
+        self.lsock, self.rsock = Rex::Compat.pipe
+      end
+
+      #
+      # This method cleans up the abstraction layer.
+      #
+      def cleanup_abstraction
+        lsock.close if lsock and !lsock.closed?
+        rsock.close if rsock and !rsock.closed?
+
+        self.lsock = nil
+        self.rsock = nil
+      end
+
+      #
+      # Low-level write to the local side.
+      #
+      def syswrite(buffer)
+        lsock.syswrite(buffer)
+      end
+
+      #
+      # Low-level read from the local side.
+      #
+      def sysread(length)
+        lsock.sysread(length)
+      end
+
+      #
+      # Shuts down the local side of the stream abstraction.
+      #
+      def shutdown(how)
+        lsock.shutdown(how)
+      end
+
+      #
+      # Closes both sides of the stream abstraction.
+      #
+      def close
+        cleanup_abstraction
+        super
+      end
+
+      #
+      # Symbolic peer information.
+      #
+      def peerinfo
+        'Remote-side of Pipe'
+      end
+
+      #
+      # Symbolic local information.
+      #
+      def localinfo
+        'Local-side of Pipe'
+      end
+
+      #
+      # The left side of the stream.
+      #
+      attr_reader :lsock
+      #
+      # The right side of the stream.
+      #
+      attr_reader :rsock
+
+      protected
+
+      def monitor_rsock(threadname = 'SocketMonitorRemote')
+        self.monitor_thread = Rex::ThreadFactory.spawn(threadname, false) do
+          loop do
+            closed = false
+            buf = nil
+
+            unless rsock
+              wlog('monitor_rsock: the remote socket is nil, exiting loop')
+              break
             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
 
-        if( closed == false )
-          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 = self.write( data )
+              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
 
-              # sf: Only remove the data off the queue is write was successfull.
-              #     This way we naturally perform a resend if a failure occured.
-              #     Catches an edge case with meterpreter TCP channels where remote send
-              #     failes gracefully and a resend is required.
-              if (sent.nil?)
+            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
-                wlog("monitor_rsock: failed writing, socket must be dead")
-                break
-              elsif (sent > 0)
-                total_sent += sent
+                dlog('monitor_rsock: EOF in rsock')
+              rescue ::Exception => e
+                closed = true
+                wlog("monitor_rsock: exception during read: #{e.class} #{e}")
               end
-            rescue ::IOError, ::EOFError => e
-              closed = true
-              wlog("monitor_rsock: exception during write: #{e.class} #{e}")
-              break
             end
-          end
-        end
 
-        if( closed )
-          begin
-            self.close_write if self.respond_to?('close_write')
-          rescue IOError
+            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 successfull.
+                  #     This way we naturally perform a resend if a failure occured.
+                  #     Catches an edge case with meterpreter TCP channels where remote send
+                  #     failes 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 IOError
+            end
+            break
           end
-          break
         end
       end
-    }
-  end
-
-protected
-  attr_accessor :monitor_thread
-  attr_writer :lsock
-  attr_writer :rsock
-
-end
-
-end; end
 
+      attr_accessor :monitor_thread
+      attr_writer :lsock, :rsock
+    end
+  end; end

data/lib/rex/io/stream.rb

@@ -325,21 +325,6 @@ module Stream
     16384
   end
 
-protected
-
-  #
-  # The read-write lock used to synchronize access to the stream. This is only
-  # set when synchronization has been initialized as performed by
-  # #initialize_synchronization.
-  #
-  attr_accessor :stream_lock
-
-  #
-  # A boolean flag indicating that the resource is to be closed. Blocking
-  # operations that are synchronized (such as #read and #write) should evaluate
-  # this flag and exit appropriately when there is no data to be processed.
-  attr_accessor :close_resource
-
   #
   # Synchronize non-state changing access to the stream such as read and write
   # operations. If synchronization has not been initialized, this doesn't do
@@ -366,6 +351,21 @@ protected
       self.stream_lock.unlock_write unless self.stream_lock.nil?
     end
   end
+
+protected
+
+  #
+  # The read-write lock used to synchronize access to the stream. This is only
+  # set when synchronization has been initialized as performed by
+  # #initialize_synchronization.
+  #
+  attr_accessor :stream_lock
+
+  #
+  # A boolean flag indicating that the resource is to be closed. Blocking
+  # operations that are synchronized (such as #read and #write) should evaluate
+  # this flag and exit appropriately when there is no data to be processed.
+  attr_accessor :close_resource
 end
 
 end end

data/lib/rex/stopwatch.rb

@@ -0,0 +1,23 @@
+module Rex::Stopwatch
+
+  # This provides a correct way to time an operation provided within a block.
+  #
+  # @see https://blog.dnsimple.com/2018/03/elapsed-time-with-ruby-the-right-way/
+  # @see https://ruby-doc.org/core-2.7.1/Process.html#method-c-clock_gettime
+  #
+  # @param [Symbol] unit The unit of time in which to measure the duration. The
+  #   argument is passed to Process.clock_gettime which defines the acceptable
+  #   values.
+  #
+  # @yield [] The block whose operation should be timed.
+  #
+  # @return Returns the result of the block and the elapsed time in the specified unit.
+  def self.elapsed_time(unit: :float_second)
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+    ret = yield
+    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC, unit) - start
+
+    [ret, elapsed]
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rex-core
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.1.21
 platform: ruby
 authors:
 - Metasploit Hackers
@@ -93,7 +93,7 @@ cert_chain:
   EknWpNgVhohbot1lfVAMmIhdtOVaRVcQQixWPwprDj/ydB8ryDMDosIMcw+fkoXU
   9GJsSaSRRYQ9UUkVL27b64okU8D48m8=
   -----END CERTIFICATE-----
-date: 2021-07-15 00:00:00.000000000 Z
+date: 2022-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -151,6 +151,7 @@ files:
 - lib/rex/io/stream.rb
 - lib/rex/io/stream_abstraction.rb
 - lib/rex/io/stream_server.rb
+- lib/rex/stopwatch.rb
 - lib/rex/sync.rb
 - lib/rex/sync/event.rb
 - lib/rex/sync/read_write_lock.rb