ssl_scan 0.0.1

data/lib/ssl_scan/socket/switch_board.rb

@@ -0,0 +1,289 @@
+# -*- coding: binary -*-
+require 'singleton'
+require 'thread'
+require 'ssl_scan/socket'
+
+module SSLScan
+module Socket
+
+###
+#
+# This class provides a global routing table that associates subnets with Comm
+# classes.  Comm classes are used to instantiate objects that are tied to
+# remote network entities.  For example, the Local Comm class is used to
+# building network connections directly from the local machine whereas, for
+# instance, a Meterpreter Comm would build a local socket pair that is
+# associated with a connection established by a remote entity.  This can be
+# seen as a uniform way of communicating with hosts through arbitrary
+# channels.
+#
+###
+class SwitchBoard
+
+  include Singleton
+  include Enumerable
+
+  def initialize
+    @_initialized = false
+  end
+
+  ###
+  #
+  # This class represents a logical switch board route.
+  # TODO: Enable this to work with IPv6 addresses
+  #
+  ###
+  class Route
+    def initialize(subnet, netmask, comm)
+      self.subnet      = subnet
+      self.netmask     = netmask
+      self.comm        = comm
+      self.subnet_nbo  = Socket.resolv_nbo_i(subnet)
+      self.netmask_nbo = Socket.resolv_nbo_i(netmask)
+    end
+
+    #
+    # Sort according to bitmask
+    #
+    def <=>(other)
+      self.bitmask <=> other.bitmask
+    end
+
+    #
+    # Convert the netmask to a bitmask and cache it.
+    #
+    def bitmask
+      @_bitmask = Socket.net2bitmask(self.netmask) if (@_bitmask == nil)
+      @_bitmask
+    end
+
+    attr_reader :subnet, :netmask, :comm
+    attr_reader :subnet_nbo, :netmask_nbo
+  protected
+    attr_writer :subnet, :netmask, :comm
+    attr_writer :subnet_nbo, :netmask_nbo
+  end
+
+  ##
+  #
+  # Class method wrappers
+  #
+  ##
+
+  #
+  # Adds a route to the switch board routing table using the supplied Comm
+  # instance.
+  #
+  def self.add_route(subnet, mask, comm)
+    ret = self.instance.add_route(subnet, mask, comm)
+    if ret && comm.respond_to?(:routes) && comm.routes.kind_of?(Array)
+      comm.routes << "#{subnet}/#{mask}"
+    end
+    ret
+  end
+
+  #
+  # Removes a route from the switch board routing table for the supplied
+  # subnet routing through the supplied Comm instance.
+  #
+  def self.remove_route(subnet, mask, comm)
+    ret = self.instance.remove_route(subnet, mask, comm)
+    if ret && comm.respond_to?(:routes) && comm.routes.kind_of?(Array)
+      comm.routes.delete "#{subnet}/#{mask}"
+    end
+    ret
+  end
+
+  #
+  # Flush all the routes from the switch board routing table.
+  #
+  def self.flush_routes
+    ret = self.instance.flush_routes
+  end
+
+  #
+  # Enumerate each route in the routing table.
+  #
+  def self.each(&block)
+    self.instance.each(&block)
+  end
+
+  #
+  # Returns the array of routes.
+  #
+  def self.routes
+    self.instance.routes
+  end
+
+  def self.route_exists?(subnet, mask)
+    self.instance.route_exists?(subnet, mask)
+  end
+
+  #
+  # Returns the Comm instance that should be used for the supplied address.
+  # If no comm can be found, the default Local Comm is returned.
+  #
+  def self.best_comm(addr)
+    self.instance.best_comm(addr)
+  end
+
+  #
+  # Removes all routes that go through the supplied Comm.
+  #
+  def self.remove_by_comm(comm)
+    self.instance.remove_by_comm(comm)
+  end
+
+  ##
+  #
+  # Instance methods
+  #
+  ##
+
+  #
+  # Adds a route for a given subnet and netmask destined through a given comm
+  # instance.
+  #
+  def add_route(subnet, mask, comm)
+    # If a bitmask was supplied, convert it.
+    netmask = (mask.to_s =~ /^\d+$/) ? Rex::Socket.bit2netmask(mask.to_i) : mask
+    rv      = true
+
+    _init
+
+    mutex.synchronize {
+      # If the route already exists, return false to the caller.
+      if (route_exists?(subnet, netmask) == false)
+        self.routes << Route.new(subnet, netmask, comm)
+      else
+        rv = false
+      end
+    }
+
+    rv
+  end
+
+  #
+  # Removes a route for a given subnet and netmask destined through a given
+  # comm instance.
+  #
+  def remove_route(subnet, mask, comm)
+    # If a bitmask was supplied, convert it.
+    netmask = (mask.to_s =~ /^\d+$/) ? Rex::Socket.bit2netmask(mask.to_i) : mask
+    rv      = false
+
+    _init
+
+    mutex.synchronize {
+      self.routes.delete_if { |route|
+        if (route.subnet == subnet and route.netmask == netmask and route.comm == comm)
+          rv = true
+        else
+          false
+        end
+      }
+    }
+
+    rv
+  end
+
+  #
+  # Flushes all established routes.
+  #
+  def flush_routes
+    _init
+
+    # Remove each of the individual routes so the comms don't think they're
+    # still routing after a flush.
+    self.routes.each { |r|
+      if r.comm.respond_to? :routes
+        r.comm.routes.delete("#{r.subnet}/#{r.netmask}")
+      end
+    }
+    # Re-initialize to an empty array
+    self.routes = Array.new
+  end
+
+  #
+  # Checks to see if a route already exists for the supplied subnet and
+  # netmask.
+  #
+  def route_exists?(subnet, netmask)
+    each { |route|
+      return true if (route.subnet == subnet and route.netmask == netmask)
+    }
+
+    false
+  end
+
+  #
+  # Enumerates each entry in the routing table.
+  #
+  def each(&block)
+    _init
+
+    routes.each(&block)
+  end
+
+  #
+  # Finds the best possible comm for the supplied target address.
+  #
+  def best_comm(addr)
+
+    addr_nbo = Socket.resolv_nbo_i(addr)
+    comm     = nil
+    msb      = 0
+
+    each { |route|
+      if ((route.subnet_nbo & route.netmask_nbo) ==
+          (addr_nbo & route.netmask_nbo))
+        if (route.bitmask >= msb)
+          comm = route.comm
+          msb  = route.bitmask
+        end
+      end
+    }
+
+    comm
+  end
+
+  #
+  # Remove all routes that go through the supplied comm.
+  #
+  def remove_by_comm(comm)
+    _init
+    mutex.synchronize {
+      routes.delete_if { |route|
+        route.comm == comm
+      }
+    }
+  end
+
+  #
+  # The routes array.
+  #
+  attr_reader :routes
+  #
+  # The mutex protecting the routes array.
+  #
+  attr_reader :mutex
+
+protected
+
+  attr_writer :routes, :mutex # :nodoc:
+
+  #
+  # Initializes the underlying stuff.
+  #
+  def _init
+    if (@_initialized != true)
+      @_initialized = true
+      self.routes   = Array.new
+      self.mutex    = Mutex.new
+    end
+  end
+
+end
+
+end
+end

data/lib/ssl_scan/socket/tcp.rb

@@ -0,0 +1,79 @@
+# -*- coding: binary -*-
+require 'ssl_scan/socket'
+require 'ssl_scan/io/stream'
+
+###
+#
+# This class provides methods for interacting with a TCP client connection.
+#
+###
+module SSLScan::Socket::Tcp
+
+  include SSLScan::Socket
+  include SSLScan::IO::Stream
+
+  ##
+  #
+  # Factory
+  #
+  ##
+
+  #
+  # Creates the client using the supplied hash.
+  #
+  # @see create_param
+  # @see SSLScan::Socket::Parameters.from_hash
+  def self.create(hash = {})
+    hash['Proto'] = 'tcp'
+    self.create_param(SSLScan::Socket::Parameters.from_hash(hash))
+  end
+
+  #
+  # Wrapper around the base socket class' creation method that automatically
+  # sets the parameter's protocol to TCP.
+  #
+  def self.create_param(param)
+    param.proto = 'tcp'
+    SSLScan::Socket.create_param(param)
+  end
+
+  ##
+  #
+  # Stream mixin implementations
+  #
+  ##
+
+  #
+  # Calls shutdown on the TCP connection.
+  #
+  def shutdown(how = ::Socket::SHUT_RDWR)
+    begin
+      return (super(how) == 0)
+    rescue ::Exception
+    end
+  end
+
+  #
+  # Returns peer information (host + port) in host:port format.
+  #
+  def peerinfo
+    if (pi = getpeername)
+      return pi[1] + ':' + pi[2].to_s
+    end
+  end
+
+  #
+  # Returns local information (host + port) in host:port format.
+  #
+  def localinfo
+    if (pi = getlocalname)
+      return pi[1] + ':' + pi[2].to_s
+    end
+  end
+
+  # returns socket type
+  def type?
+    return 'tcp'
+  end
+
+end

data/lib/ssl_scan/socket/tcp_server.rb

@@ -0,0 +1,67 @@
+# -*- coding: binary -*-
+require 'ssl_scan/socket'
+require 'ssl_scan/socket/tcp'
+require 'ssl_scan/io/stream_server'
+
+###
+#
+# This class provides methods for interacting with a TCP server.  It
+# implements the SSLScan::IO::StreamServer interface.
+#
+###
+module  SSLScan::Socket::TcpServer
+
+  include SSLScan::Socket
+  include SSLScan::IO::StreamServer
+
+  ##
+  #
+  # Factory
+  #
+  ##
+
+  #
+  # Creates the server using the supplied hash.
+  #
+  def self.create(hash = {})
+    hash['Proto'] = 'tcp'
+    hash['Server'] = true
+    self.create_param(SSLScan::Socket::Parameters.from_hash(hash))
+  end
+
+  #
+  # Wrapper around the base class' creation method that automatically sets
+  # the parameter's protocol to TCP and sets the server flag to true.
+  #
+  def self.create_param(param)
+    param.proto  = 'tcp'
+    param.server = true
+    SSLScan::Socket.create_param(param)
+  end
+
+  #
+  # Accepts a child connection.
+  #
+  def accept(opts = {})
+    t = super()
+
+    # jRuby compatibility
+    if t.respond_to?('[]')
+      t = t[0]
+    end
+
+    if (t)
+      t.extend(SSLScan::Socket::Tcp)
+      t.context = self.context
+
+      pn = t.getpeername
+
+      t.peerhost = pn[1]
+      t.peerport = pn[2]
+    end
+
+    t
+  end
+
+end
+

data/lib/ssl_scan/socket/udp.rb

@@ -0,0 +1,165 @@
+# -*- coding: binary -*-
+require 'ssl_scan/socket'
+
+###
+#
+# This class provides methods for interacting with a UDP socket.
+#
+###
+module SSLScan::Socket::Udp
+
+  include SSLScan::Socket
+
+  ##
+  #
+  # Factory
+  #
+  ##
+
+  #
+  # Creates the client using the supplied hash.
+  #
+  def self.create(hash = {})
+    hash['Proto'] = 'udp'
+    # If we have are to bind to a LocalHost we must be a Server to avail of pivoting.
+    # SSLScan::Socket::Parameters will subsequently turn off the sever flag after the correct
+    # comm has been chosen.
+    if( hash['LocalHost'] )
+      hash['Server'] = true
+    end
+    self.create_param(SSLScan::Socket::Parameters.from_hash(hash))
+  end
+
+  #
+  # Wrapper around the base socket class' creation method that automatically
+  # sets the parameter's protocol to UDP.
+  #
+  def self.create_param(param)
+    param.proto = 'udp'
+    SSLScan::Socket.create_param(param)
+  end
+
+  ##
+  #
+  # UDP connected state methods
+  #
+  ##
+
+  #
+  # Write the supplied datagram to the connected UDP socket.
+  #
+  def write(gram)
+    begin
+      return syswrite(gram)
+    rescue  ::Errno::EHOSTUNREACH,::Errno::ENETDOWN,::Errno::ENETUNREACH,::Errno::ENETRESET,::Errno::EHOSTDOWN,::Errno::EACCES,::Errno::EINVAL,::Errno::EADDRNOTAVAIL
+      return nil
+    end
+  end
+
+  alias put write
+
+  #
+  # Read a datagram from the UDP socket.
+  #
+  def read(length = 65535)
+    if length < 0
+      length = 65535
+    end
+    return sysread(length)
+  end
+
+  #
+  # Read a datagram from the UDP socket with a timeout
+  #
+  def timed_read(length = 65535, timeout=def_read_timeout)
+    begin
+      if ((rv = ::IO.select([ fd ], nil, nil, timeout)) and
+          (rv[0]) and (rv[0][0] == fd)
+         )
+          return read(length)
+      else
+        return ''
+      end
+    rescue Exception
+      return ''
+    end
+  end
+
+  #alias send write
+  #alias recv read
+
+  ##
+  #
+  # UDP non-connected state methods
+  #
+  ##
+
+  #
+  # Sends a datagram to the supplied host:port with optional flags.
+  #
+  def sendto(gram, peerhost, peerport, flags = 0)
+
+    # Catch unconnected IPv6 sockets talking to IPv4 addresses
+    peer = SSLScan::Socket.resolv_nbo(peerhost)
+    if (peer.length == 4 and self.ipv == 6)
+      peerhost = SSLScan::Socket.getaddress(peerhost, true)
+      if peerhost[0,7].downcase != '::ffff:'
+        peerhost = '::ffff:' + peerhost
+      end
+    end
+
+    begin
+      send(gram, flags, SSLScan::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
+
+  end
+
+  #
+  # Receives a datagram and returns the data and host:port of the requestor
+  # as [ data, host, port ].
+  #
+  def recvfrom(length = 65535, timeout=def_read_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 = SSLScan::Socket.from_sockaddr(saddr)
+
+          return [ data, host, port ]
+      else
+        return [ '', nil, nil ]
+      end
+    rescue ::Timeout::Error
+      return [ '', nil, nil ]
+    rescue ::Interrupt
+      raise $!
+    rescue ::Exception
+      return [ '', nil, nil ]
+    end
+  end
+
+  #
+  # Calls recvfrom and only returns the data
+  #
+  def get(timeout=nil)
+    data, saddr, sport = recvfrom(65535, timeout)
+    return data
+  end
+
+  #
+  # The default number of seconds to wait for a read operation to timeout.
+  #
+  def def_read_timeout
+    10
+  end
+
+  def type?
+    return 'udp'
+  end
+
+end
+