rex-socket 0.1.67 → 0.1.69

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d08e421781956b8e7f7cae6c731fb1589401f375774dbe51fde3dba15170ae3c
-  data.tar.gz: 646375e1d851896604d9b4b342bc1158fb0628b42a659fe58622551a66bb097d
+  metadata.gz: 06a8d5b9b8dff6b4e9ef66dbccf00522bacff3f3e7e7b011f13a3548cd595f6d
+  data.tar.gz: 3fb1e4a3d8a356468b9ff998d7001eacd001ff825d97bf7ffae41b88489d2be3
 SHA512:
-  metadata.gz: 850daee218c584254d1eaf047ad3843b4fcaa648a83add08ae29c71c9142be59613239e6bf46c7c1996b3710bfb02b271320f62ff8d55b3f93c1a2073bd286a2
-  data.tar.gz: 3fc4e74930e01ff0a54a22b7f135e83e49693a053b397619b00b2e7ede551cfd4875946c00d46fa537508266c2c79ca68af5d87e0ce970a9e23b1d0e880e7a6d
+  metadata.gz: d75a50f35c0853ad85026916638d1cea6724d4fbdf52f704bc396872ee85228c0f1db096b443ad52bc1631fb52e220e6ef44c024352e958df50b554043a68930
+  data.tar.gz: cd78a56eec5f4b4e780cf496eca88452057786065d300a0db2cb7eba00fa962d94c9c0e0227e73cb78a3931f018ae58259546e874b945cd154829f397d635320

data/lib/rex/socket/udp.rb

@@ -97,57 +97,98 @@ module Rex::Socket::Udp
   #
   # Sends a datagram to the supplied host:port with optional flags.
   #
+  # @deprecated Use {#send} with the stdlib 4-arg form send(mesg, flags, host, port) instead.
+  #   Note the argument order differs: sendto(gram, host, port, flags) vs send(mesg, flags, host, port).
+  #
   def sendto(gram, peerhost, peerport, flags = 0)
+    warn "#{self.class}#sendto is deprecated; use send(mesg, flags, host, port) instead", uplevel: 1
+    send(gram, flags, peerhost, peerport)
+  end
 
-    # Catch unconnected IPv6 sockets talking to IPv4 addresses
-    peer = Rex::Socket.resolv_nbo(peerhost)
-    if (peer.length == 4 and self.ipv == 6)
-      peerhost = Rex::Socket.getaddress(peerhost, true)
-      if peerhost[0,7].downcase != '::ffff:'
-        peerhost = '::ffff:' + peerhost
+  #
+  # Sends a datagram using the stdlib 4-arg form send(mesg, flags, host, port).
+  #
+  # The 4-arg form handles IPv6/IPv4 address mapping and dispatches via
+  # BasicSocket#send with a packed sockaddr, so channel/pivoted sockets that
+  # override sendto are not involved. Also accepts the 3-arg sockaddr form used
+  # by lower-level callers, and the 2-arg connected-socket form.
+  #
+  def send(mesg, flags, host = nil, port = nil)
+    if host && port
+      # Catch unconnected IPv6 sockets talking to IPv4 addresses
+      peer = Rex::Socket.resolv_nbo(host)
+      if peer.length == 4 && self.ipv == 6
+        host_address = Rex::Socket.getaddress(host, true)
+        host = '::ffff:' + host_address unless host_address.downcase.start_with?('::ffff:')
       end
+      begin
+        super(mesg, flags, Rex::Socket.to_sockaddr(host, port))
+      rescue ::Errno::EHOSTUNREACH, ::Errno::ENETDOWN, ::Errno::ENETUNREACH, ::Errno::ENETRESET,
+             ::Errno::EHOSTDOWN, ::Errno::EACCES, ::Errno::EINVAL, ::Errno::EADDRNOTAVAIL
+        nil
+      end
+    elsif host
+      super(mesg, flags, host)
+    else
+      super(mesg, flags)
     end
+  end
 
-    begin
-      send(gram, flags, Rex::Socket.to_sockaddr(peerhost, peerport))
-    rescue  ::Errno::EHOSTUNREACH,::Errno::ENETDOWN,::Errno::ENETUNREACH,::Errno::ENETRESET,::Errno::EHOSTDOWN,::Errno::EACCES,::Errno::EINVAL,::Errno::EADDRNOTAVAIL
-      return nil
-    end
-
+  #
+  # Receives a datagram and returns the data and sender address information as
+  # [ data, [address_family, port, host, host] ], matching stdlib
+  # UDPSocket#recvfrom. Like the stdlib method, this blocks until a datagram is
+  # available and has no timeout of its own (see #timed_recvfrom for a variant
+  # that does). The host appears in both the hostname and numeric address
+  # positions; no reverse-DNS lookup is performed.
+  #
+  # @param maxlen [Integer] maximum number of bytes to receive
+  # @param flags [Integer] flags passed to the underlying recvfrom(2) call (default: 0)
+  # @return [Array(String, Array)] the datagram and the sender address information
+  #
+  def recvfrom(maxlen, flags = 0)
+    # Block until the socket is readable to mirror the stdlib's blocking
+    # UDPSocket#recvfrom; a nil timeout waits indefinitely.
+    ::IO.select([ fd ], nil, nil, nil)
+    data, saddr = recvfrom_nonblock(maxlen, flags)
+    [ data, sender_addr_info(saddr) ]
   end
 
   #
-  # Receives a datagram and returns the data and host:port of the requestor
-  # as [ data, host, port ].
+  # Receives a datagram like #recvfrom but waits at most +timeout+ seconds for
+  # one to arrive, returning nil if the timeout elapses first. The return value
+  # otherwise matches #recvfrom: [ data, [address_family, port, host, host] ].
   #
-  def recvfrom(length = 65535, timeout=def_read_timeout)
+  # @param maxlen [Integer] maximum number of bytes to receive
+  # @param timeout [Numeric] seconds to wait for a datagram before giving up
+  # @return [Array(String, Array), nil] the datagram and sender address
+  #   information, or nil if no datagram arrived within +timeout+ seconds
+  #
+  def timed_recvfrom(maxlen = 65535, timeout = def_read_timeout)
+    return nil unless ::IO.select([ fd ], nil, nil, timeout)
 
-    begin
-      if ((rv = ::IO.select([ fd ], nil, nil, timeout)) and
-          (rv[0]) and (rv[0][0] == fd)
-         )
-          data, saddr    = recvfrom_nonblock(length)
-          af, host, port = Rex::Socket.from_sockaddr(saddr)
+    data, saddr = recvfrom_nonblock(maxlen)
+    [ data, sender_addr_info(saddr) ]
+  rescue ::Timeout::Error, ::Errno::ECONNREFUSED
+    nil
+  end
 
-          return [ data, host, port ]
-      else
-        return [ '', nil, nil ]
-      end
-    rescue ::Timeout::Error
-      return [ '', nil, nil ]
-    rescue ::Interrupt
-      raise $!
-    rescue ::Exception
-      return [ '', nil, nil ]
-    end
+  #
+  # Converts a packed sockaddr into the stdlib UDPSocket#recvfrom-style sender
+  # address tuple [ address_family, port, host, host ].
+  #
+  def sender_addr_info(saddr)
+    af, host, port = Rex::Socket.from_sockaddr(saddr)
+    af_name = ::Socket.constants.grep(/^AF_/).find { |c| ::Socket.const_get(c) == af }.to_s
+    [ af_name, port, host, host ]
   end
+  private :sender_addr_info
 
   #
-  # Calls recvfrom and only returns the data
+  # Calls #timed_read and returns the data
   #
   def get(timeout=nil)
-    data, saddr, sport = recvfrom(65535, timeout)
-    return data
+    timed_read(65535, timeout)
   end
 
   #

data/lib/rex/socket/version.rb

@@ -1,5 +1,5 @@
 module Rex
   module Socket
-    VERSION = "0.1.67"
+    VERSION = "0.1.69"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rex-socket
 version: !ruby/object:Gem::Version
-  version: 0.1.67
+  version: 0.1.69
 platform: ruby
 authors:
 - Metasploit Hackers
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-27 00:00:00.000000000 Z
+date: 2026-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake