rex-core 0.1.21 → 0.1.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ab976e408acf491f30c2d5ec12fde516b6ceebf75257216a07997dccee92ba5
-  data.tar.gz: 382f26dd0e86f8245bdbdde3462f5555080a6f85a03b76a7a164ab4b796c7672
+  metadata.gz: 92383c2b5e9cf999abfc198c12992d176cfdf262fbd782886ef1ea1a705f2fd6
+  data.tar.gz: 584ffd804e8c5b1d3b96c5cf90580553fb12513c958362d93238cf92545c7184
 SHA512:
-  metadata.gz: 27ca06a5a3a339a079c2b177dbb034737e1836a2b9a14edfd48accc04912a803c8158eebc6f800425fbcbaccf86abfc22d2a7892cc4650e073927a758cf11c14
-  data.tar.gz: a4b223838152b1eb302bc3ff52298b60d9ed25f5eb9d920eb6a526607d5490f4fdaa89f8135913c15b66cbce0cf54a6be5b263faf717d299000dcc368491b6fd
+  metadata.gz: fc7aa81e629107d66ceefdee7fcde2f7620fd95aff8bb2f163eacd31387835e84f123bdda4666b5e4c6a3390db5a9ddb4a55e8a15850c670ad0610c479ac2816
+  data.tar.gz: 5d4b2fd53ec1cb320a5d503d97ff4f478f330368f98c3230cc1918edf1d07a9f950c2bef7d0210074e52ce1ee16097f3e32703b4476cd16d7d3edb651c26e35e

data/.github/workflows/verify.yml

@@ -0,0 +1,45 @@
+name: Verify
+
+on:
+  push:
+    branches:
+      - '*'
+  pull_request:
+    branches:
+      - '*'
+
+jobs:
+  test:
+    runs-on: ubuntu-18.04
+    timeout-minutes: 40
+
+    strategy:
+      fail-fast: true
+      matrix:
+        ruby:
+          - 2.6
+          - 2.7
+          - 3.0
+        test_cmd:
+          - bundle exec rspec
+
+    env:
+      RAILS_ENV: test
+
+    name: Ruby ${{ matrix.ruby }} - ${{ matrix.test_cmd }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - name: ${{ matrix.test_cmd }}
+        run: |
+          echo "${CMD}"
+          bash -c "${CMD}"
+        env:
+          CMD: ${{ matrix.test_cmd }}

data/lib/rex/core/version.rb

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

data/lib/rex/io/socket_abstraction.rb

@@ -53,6 +53,9 @@ module Rex
       #
       def cleanup_abstraction
         lsock.close if lsock and !lsock.closed?
+
+        monitor_thread.join if monitor_thread&.alive?
+
         rsock.close if rsock and !rsock.closed?
 
         self.lsock = nil
@@ -111,19 +114,36 @@ module Rex
       #
       attr_reader :rsock
 
+      module MonitoredRSock
+        def close
+          @close_requested = true
+          @monitor_thread.join
+          nil
+        end
+
+        def sysclose
+          self.class.instance_method(:close).bind(self).call
+        end
+
+        attr_reader :close_requested
+        attr_writer :monitor_thread
+      end
+
       protected
 
       def monitor_rsock(threadname = 'SocketMonitorRemote')
-        self.monitor_thread = Rex::ThreadFactory.spawn(threadname, false) do
+        rsock.extend(MonitoredRSock)
+        rsock.monitor_thread = self.monitor_thread = Rex::ThreadFactory.spawn(threadname, false) do
           loop do
-            closed = false
-            buf = nil
+            closed = rsock.nil? || rsock.close_requested
 
-            unless rsock
-              wlog('monitor_rsock: the remote socket is nil, exiting loop')
+            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?
@@ -159,10 +179,10 @@ module Rex
                   # 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.
+                  # 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
-                  #     failes gracefully and a resend is required.
+                  #     fails gracefully and a resend is required.
                   if sent.nil?
                     closed = true
                     wlog('monitor_rsock: failed writing, socket must be dead')
@@ -182,14 +202,18 @@ module Rex
 
             begin
               close_write if respond_to?('close_write')
-            rescue IOError
+            rescue StandardError
             end
+
             break
           end
+
+          rsock.sysclose
         end
       end
 
       attr_accessor :monitor_thread
       attr_writer :lsock, :rsock
     end
-  end; end
+  end
+end

data/lib/rex/io/stream_server.rb

@@ -1,228 +1,208 @@
 # -*- coding: binary -*-
-require 'thread'
 
 module Rex
-module IO
-
-###
-#
-# This mixin provides the framework and interface for implementing a streaming
-# server that can listen for and accept stream client connections.  Stream
-# servers extend this class and are required to implement the following
-# methods:
-#
-#   accept
-#   fd
-#
-###
-module StreamServer
-
-  ##
-  #
-  # Abstract methods
-  #
-  ##
-
-  ##
-  #
-  # Default server monitoring and client management implementation follows
-  # below.
-  #
-  ##
-
-  #
-  # This callback is notified when a client connects.
-  #
-  def on_client_connect(client)
-    if (on_client_connect_proc)
-      on_client_connect_proc.call(client)
-    end
-  end
-
-  #
-  # This callback is notified when a client connection has data that needs to
-  # be processed.
-  #
-  def on_client_data(client)
-    if (on_client_data_proc)
-      on_client_data_proc.call(client)
-    end
-  end
-
-  #
-  # This callback is notified when a client connection has closed.
-  #
-  def on_client_close(client)
-    if (on_client_close_proc)
-      on_client_close_proc.call(client)
-    end
-  end
-
-  #
-  # Start monitoring the listener socket for connections and keep track of
-  # all client connections.
-  #
-  def start
-    self.clients = []
-    self.client_waiter = ::Queue.new
-
-    self.listener_thread = Rex::ThreadFactory.spawn("StreamServerListener", false) {
-      monitor_listener
-    }
-    self.clients_thread = Rex::ThreadFactory.spawn("StreamServerClientMonitor", false) {
-      monitor_clients
-    }
-  end
-
-  #
-  # Terminates the listener monitoring threads and closes all active clients.
-  #
-  def stop
-    self.listener_thread.kill
-    self.clients_thread.kill
-
-    self.clients.each { |cli|
-      close_client(cli)
-    }
-  end
+  module IO
+    ###
+    #
+    # This mixin provides the framework and interface for implementing a streaming
+    # server that can listen for and accept stream client connections.  Stream
+    # servers extend this class and are required to implement the following
+    # methods:
+    #
+    #   accept
+    #   fd
+    #
+    ###
+    module StreamServer
+      ##
+      #
+      # Abstract methods
+      #
+      ##
+
+      ##
+      #
+      # Default server monitoring and client management implementation follows
+      # below.
+      #
+      ##
+
+      #
+      # This callback is notified when a client connects.
+      #
+      def on_client_connect(client)
+        on_client_connect_proc.call(client) if on_client_connect_proc
+      end
 
-  #
-  # This method closes a client connection and cleans up the resources
-  # associated with it.
-  #
-  def close_client(client)
-    if (client)
-      detach_client(client)
-
-      begin
-        client.close
-      rescue IOError
+      #
+      # This callback is notified when a client connection has data that needs to
+      # be processed.
+      #
+      def on_client_data(client)
+        on_client_data_proc.call(client) if on_client_data_proc
       end
-    end
-  end
 
-  #
-  # Detach a client. You are now responsible for it, not us
-  #
-  def detach_client(client)
-    self.clients.delete(client)
-  end
+      #
+      # This callback is notified when a client connection has closed.
+      #
+      def on_client_close(client)
+        on_client_close_proc.call(client) if on_client_close_proc
+      end
 
-  #
-  # This method waits on the server listener thread
-  #
-  def wait
-    self.listener_thread.join if self.listener_thread
-  end
+      #
+      # Start monitoring the listener socket for connections and keep track of
+      # all client connections.
+      #
+      def start
+        self.clients = []
+        self.client_waiter = ::Queue.new
 
-  ##
-  #
-  # Callback procedures.
-  #
-  ##
-
-  #
-  # This callback procedure can be set and will be called when new clients
-  # connect.
-  #
-  attr_accessor :on_client_connect_proc
-  #
-  # This callback procedure can be set and will be called when clients
-  # have data to be processed.
-  #
-  attr_accessor :on_client_data_proc
-  #
-  # This callback procedure can be set and will be called when a client
-  # disconnects from the server.
-  #
-  attr_accessor :on_client_close_proc
-
-  attr_accessor :clients # :nodoc:
-  attr_accessor :listener_thread, :clients_thread # :nodoc:
-  attr_accessor :client_waiter
-
-protected
-
-  #
-  # This method monitors the listener socket for new connections and calls
-  # the +on_client_connect+ callback routine.
-  #
-  def monitor_listener
-
-    while true
-      begin
-        cli = accept
-        if not cli
-          elog("The accept() returned nil in stream server listener monitor:  #{fd.inspect}")
-          ::IO.select(nil, nil, nil, 0.10)
-          next
+        self.listener_thread = Rex::ThreadFactory.spawn('StreamServerListener', false) do
+          monitor_listener
         end
+        self.clients_thread = Rex::ThreadFactory.spawn('StreamServerClientMonitor', false) do
+          monitor_clients
+        end
+      end
 
-        # Append to the list of clients
-        self.clients << cli
+      #
+      # Terminates the listener monitoring threads and closes all active clients.
+      #
+      def stop
+        listener_thread.kill
+        clients_thread.kill
 
-        # Initialize the connection processing
-        on_client_connect(cli)
+        clients.each do |cli|
+          close_client(cli)
+        end
+      end
 
-        # Notify the client monitor
-        self.client_waiter.push(cli)
+      #
+      # This method closes a client connection and cleans up the resources
+      # associated with it.
+      #
+      def close_client(client)
+        if client
+          detach_client(client)
+
+          begin
+            client.close
+          rescue IOError
+          end
+        end
+      end
 
-      # Skip exceptions caused by accept() [ SSL ]
-      rescue ::EOFError, ::Errno::ECONNRESET, ::Errno::ENOTCONN, ::Errno::ECONNABORTED
-      rescue ::Interrupt
-        raise $!
-      rescue ::Exception
-        elog("Error in stream server server monitor: #{$!}")
-        rlog(ExceptionCallStack)
-        break
+      #
+      # Detach a client. You are now responsible for it, not us
+      #
+      def detach_client(client)
+        clients.delete(client)
       end
-    end
-  end
 
-  #
-  # This method monitors client connections for data and calls the
-  # +on_client_data+ routine when new data arrives.
-  #
-  def monitor_clients
-    begin
-
-      # Wait for a notify if our client list is empty
-      if (clients.length == 0)
-        self.client_waiter.pop
-        next
+      #
+      # This method waits on the server listener thread
+      #
+      def wait
+        listener_thread.join if listener_thread
       end
 
-      sd = Rex::ThreadSafe.select(clients, nil, nil, nil)
+      ##
+      #
+      # Callback procedures.
+      #
+      ##
+
+      #
+      # This callback procedure can be set and will be called when new clients
+      # connect.
+      #
+      attr_accessor :on_client_connect_proc
+      #
+      # This callback procedure can be set and will be called when clients
+      # have data to be processed.
+      #
+      attr_accessor :on_client_data_proc
+      #
+      # This callback procedure can be set and will be called when a client
+      # disconnects from the server.
+      #
+      attr_accessor :on_client_close_proc
+
+      attr_accessor :clients, :listener_thread, :clients_thread, :client_waiter # :nodoc: # :nodoc:
+
+      protected
+
+      #
+      # This method monitors the listener socket for new connections and calls
+      # the +on_client_connect+ callback routine.
+      #
+      def monitor_listener
+        while true
+          begin
+            cli = accept
+            unless cli
+              elog('The accept() returned nil in stream server listener monitor')
+              ::IO.select(nil, nil, nil, 0.10)
+              next
+            end
+
+            # Append to the list of clients
+            clients << cli
+
+            # Initialize the connection processing
+            on_client_connect(cli)
+
+            # Notify the client monitor
+            client_waiter.push(cli)
+
+          # Skip exceptions caused by accept() [ SSL ]
+          rescue ::EOFError, ::Errno::ECONNRESET, ::Errno::ENOTCONN, ::Errno::ECONNABORTED
+          rescue ::Interrupt
+            raise $!
+          rescue ::Exception
+            elog("Error in stream server server monitor: #{$!}")
+            rlog(ExceptionCallStack)
+            break
+          end
+        end
+      end
 
-      sd[0].each { |cfd|
+      #
+      # This method monitors client connections for data and calls the
+      # +on_client_data+ routine when new data arrives.
+      #
+      def monitor_clients
         begin
-          on_client_data(cfd) if clients.include? cfd
-        rescue ::EOFError, ::Errno::ECONNRESET, ::Errno::ENOTCONN, ::Errno::ECONNABORTED
-          on_client_close(cfd)
-          close_client(cfd)
+          # Wait for a notify if our client list is empty
+          if clients.length == 0
+            client_waiter.pop
+            next
+          end
+
+          sd = Rex::ThreadSafe.select(clients, nil, nil, nil)
+
+          sd[0].each do |cfd|
+            on_client_data(cfd) if clients.include? cfd
+          rescue ::EOFError, ::Errno::ECONNRESET, ::Errno::ENOTCONN, ::Errno::ECONNABORTED
+            on_client_close(cfd)
+            close_client(cfd)
+          rescue ::Interrupt
+            raise $!
+          rescue ::Exception
+            close_client(cfd)
+            elog("Error in stream server client monitor: #{$!}")
+            rlog(ExceptionCallStack)
+          end
+        rescue ::Rex::StreamClosedError => e
+          # Remove the closed stream from the list
+          detach_client(e.stream)
         rescue ::Interrupt
           raise $!
         rescue ::Exception
-          close_client(cfd)
           elog("Error in stream server client monitor: #{$!}")
           rlog(ExceptionCallStack)
-
-        end
-      }
-
-    rescue ::Rex::StreamClosedError => e
-      # Remove the closed stream from the list
-      detach_client(e.stream)
-    rescue ::Interrupt
-      raise $!
-    rescue ::Exception
-      elog("Error in stream server client monitor: #{$!}")
-      rlog(ExceptionCallStack)
-    end while true
+        end while true
+      end
+    end
   end
-
 end
-
-end
-end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rex-core
 version: !ruby/object:Gem::Version
-  version: 0.1.21
+  version: 0.1.25
 platform: ruby
 authors:
 - Metasploit Hackers
@@ -93,7 +93,7 @@ cert_chain:
   EknWpNgVhohbot1lfVAMmIhdtOVaRVcQQixWPwprDj/ydB8ryDMDosIMcw+fkoXU
   9GJsSaSRRYQ9UUkVL27b64okU8D48m8=
   -----END CERTIFICATE-----
-date: 2022-01-25 00:00:00.000000000 Z
+date: 2022-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -132,6 +132,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/verify.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"