bettercap 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54766752ef4193add9d30875e978316b4489c9f2
-  data.tar.gz: dd4a0475d6156464f1bbb7b2b0bc55be09e32afc
+  metadata.gz: 5a754804a6aed2eab487b2fbe33417c222946953
+  data.tar.gz: 0ba2e64fc445000c10b7dd9d2d3ec94c47108dbe
 SHA512:
-  metadata.gz: e073d1158b3cc7f6125d7e7b98cf6f41712c491d4687418bed7d647a2435c1ff10f8c41cda3987a19c894a33351648c1fdda1e5db090286280e8f7224136e284
-  data.tar.gz: 538f6f46aaf601822f7b582e5da4a3432bbe57f3bb17f71f197163ea46447cac9377f909dcf98fca39cd18f67385cb2299a528a495d0137ade3530e25364e93a
+  metadata.gz: 4bda0263ceae34eee565a7d5b46400f573b623a7a46f343dd9396a95078cdf2a4118fe2580f748d5c77a0174f589a5b505f466d125585824f5d54dd43457dbb3
+  data.tar.gz: 4fa729af4ff2b4a890ab87f53aed5559702e8d82efee9e55986467f28337f652234ca5322b69c20761758d6f6ec0916368f8ae922649100dda50c1d8695e268a

data/lib/bettercap/discovery/agents/arp.rb

@@ -18,6 +18,7 @@ module Agents
 class Arp < Discovery::Agents::Base
   private
 
+  # Build a PacketFu::ARPPacket instance for the specified +ip+ address.
   def get_probe( ip )
     pkt = PacketFu::ARPPacket.new
 

data/lib/bettercap/discovery/agents/base.rb

@@ -38,6 +38,7 @@ class Base
 
   private
 
+  # Each Discovery::Agent::Base derived class should implement this method.
   def get_probe( ip )
     Logger.warn "#{self.class.name}#get_probe not implemented!"
   end

data/lib/bettercap/discovery/agents/icmp.rb

@@ -17,8 +17,7 @@ module Agents
 # Class responsible to do a ping-sweep on the network.
 class Icmp
   # Create a thread which will perform a ping-sweep on the network in order
-  # to populate the ARP cache with active targets, with a +ctx.timeout+ seconds
-  # timeout.
+  # to populate the ARP cache with active targets.
   def initialize( ctx )
     Factories::Firewall.get.enable_icmp_bcast(true)
 

data/lib/bettercap/discovery/agents/udp.rb

@@ -18,6 +18,7 @@ module Agents
 class Udp < Discovery::Agents::Base
   private
 
+  # Build an UDP packet for the specified +ip+ address.
   def get_probe( ip )
     # send dummy udp packet, just to fill ARP table
     [ ip.to_s, 137, "\x10\x12\x85\x00\x00" ]

data/lib/bettercap/discovery/thread.rb

@@ -40,6 +40,8 @@ class Thread
 
   private
 
+  # This method implements the main discovery logic, it will be executed within
+  # the spawned thread.
   def worker
     Logger.debug( 'Network discovery thread started.' ) unless @ctx.options.arpcache
 
@@ -48,7 +50,7 @@ class Thread
       @ctx.targets = Network.get_alive_targets(@ctx).sort_by { |t| t.sortable_ip }
 
       if was_empty and not @ctx.targets.empty?
-        Logger.info "Collected #{@ctx.targets.size} total targets."
+        Logger.info "Collected #{@ctx.targets.size} total target#{if @ctx.targets.size > 1 then "s" else "" end}."
 
         msg = "\n"
         @ctx.targets.each do |target|

data/lib/bettercap/factories/spoofer.rb

@@ -42,6 +42,7 @@ class Spoofer
 
     private
 
+    # Return true if +name+ is a valid spoofer name, otherwise false.
     def available?(name)
       available.include?(name)
     end

data/lib/bettercap/firewalls/base.rb

@@ -68,6 +68,7 @@ class Base
 
 private
 
+  # Method used to raise NotImplementedError exception.
   def not_implemented_method!
     raise NotImplementedError, 'Firewalls::Base: Unimplemented method!'
   end

data/lib/bettercap/logger.rb

@@ -73,6 +73,7 @@ module Logger
 
     private
 
+    # Main logger logic.
     def worker
       loop do
         message = @@queue.pop
@@ -82,6 +83,7 @@ module Logger
       end
     end
 
+    # Emit the +message+.
     def emit(message)
       puts message
       unless @@logfile.nil?
@@ -91,6 +93,7 @@ module Logger
       end
     end
 
+    # Format +message+ for the given +message_type+.
     def formatted_message(message, message_type)
       "[#{message_type}] #{message}"
     end

data/lib/bettercap/network/arp_reader.rb

@@ -58,6 +58,8 @@ class ArpReader
 
   private
 
+  # Read the computer ARP cache and parse each line, it will yield each
+  # ip and mac address it will be able to extract.
   def self.parse_cache
     iface = Context.get.ifconfig[:iface]
     Shell.arp.split("\n").each do |line|
@@ -72,6 +74,7 @@ class ArpReader
     end
   end
 
+  # Parse a single ARP cache +line+ related to the +iface+ network interface.
   def self.parse_cache_line( iface, line )
     /[^\s]+\s+\(([0-9\.]+)\)\s+at\s+([a-f0-9:]+).+#{iface}.*/i.match(line)
   end

data/lib/bettercap/network/network.rb

@@ -133,6 +133,8 @@ class << self
 
   private
 
+  # Start discovery agents and wait for +ctx.timeout+ seconds for them to
+  # complete their job.
   def start_agents( ctx )
     [ 'Icmp', 'Udp', 'Arp' ].each do |name|
       BetterCap::Loader.load("BetterCap::Discovery::Agents::#{name}").new(ctx)
@@ -140,6 +142,8 @@ class << self
     ctx.packets.wait_empty( ctx.timeout )
   end
 
+  # Search for the MAC address associated to +ip_address+ inside the +cap+
+  # PacketFu::Capture object.
   def get_mac_from_capture( cap, ip_address )
     cap.stream.each do |p|
       arp_response = PacketFu::Packet.parse(p)

data/lib/bettercap/network/packet_queue.rb

@@ -52,6 +52,8 @@ class PacketQueue
 
   private
 
+  # Unpack [ ip, port, data ] from +packet+ and send it using the global
+  # UDPSocket instance.
   def dispatch_udp_packet(packet)
     ip, port, data = packet
     @mutex.synchronize {
@@ -60,6 +62,7 @@ class PacketQueue
     }
   end
 
+  # Use the global Pcap injection instance to send the +packet+.
   def dispatch_raw_packet(packet)
     @mutex.synchronize {
       Logger.debug "Sending #{packet.class.name} packet ..."
@@ -67,6 +70,7 @@ class PacketQueue
     }
   end
 
+  # Main PacketQueue logic.
   def worker
     Logger.debug "PacketQueue worker started."
 

data/lib/bettercap/network/target.rb

@@ -114,6 +114,7 @@ class Target
 
 private
 
+  # Attempt to perform a NBNS name resolution for this target.
   def resolve!
     resp, sock = nil, nil
     begin
@@ -133,10 +134,12 @@ private
     end
   end
 
+  # Given the +resp+ NBNS response, parse the hostname from it.
   def parse_nbns_response resp
     resp[0][57,15].to_s.strip
   end
 
+  # Lookup the given +mac+ address in order to find its vendor.
   def self.lookup_vendor( mac )
     if @@prefixes == nil
       Logger.debug 'Preloading hardware vendor prefixes ...'

data/lib/bettercap/options.rb

@@ -56,8 +56,12 @@ class Options
   attr_accessor :proxy_https
   # HTTP proxy port.
   attr_accessor :proxy_port
+  # List of HTTP ports, [ 80 ] by default.
+  attr_accessor :http_ports
   # HTTPS proxy port.
   attr_accessor :proxy_https_port
+  # List of HTTPS ports, [ 443 ] by default.
+  attr_accessor :https_ports
   # File name of the PEM certificate to use for the HTTPS proxy.
   attr_accessor :proxy_pem_file
   # File name of the transparent proxy module to load.
@@ -100,7 +104,8 @@ class Options
     @no_target_nbns = false
     @kill = false
     @packet_throttle = 0.0
-
+    @http_ports = [ 80 ]
+    @https_ports = [ 443 ]
     @ignore = nil
 
     @sniffer = false
@@ -241,6 +246,14 @@ class Options
         ctx.options.proxy_port = v.to_i
       end
 
+      opts.on( '--http-ports PORT1,PORT2', 'Comma separated list of HTTP ports to redirect to the proxy, default to ' + ctx.options.http_ports.join(', ') + ' .' ) do |v|
+        ctx.options.http_ports = v
+      end
+
+      opts.on( '--https-ports PORT1,PORT2', 'Comma separated list of HTTPS ports to redirect to the proxy, default to ' + ctx.options.https_ports.join(', ') + ' .' ) do |v|
+        ctx.options.https_ports = v
+      end
+
       opts.on( '--proxy-https-port PORT', 'Set HTTPS proxy port, default to ' + ctx.options.proxy_https_port.to_s + ' .' ) do |v|
         ctx.options.proxy = true
         ctx.options.proxy_https = true
@@ -397,6 +410,32 @@ class Options
     raise BetterCap::Error, 'Invalid custom HTTPS upstream proxy address specified.' unless Network.is_ip? @custom_https_proxy
   end
 
+  # Parse a comma separated list of ports and return an array containing only
+  # valid ports, raise BetterCap::Error if that array is empty.
+  def to_ports(value)
+    ports = []
+    value.split(",").each do |v|
+      v = v.strip.to_i
+      if v > 0 and v <= 65535
+        ports << v
+      end
+    end
+    raise BetterCap::Error, 'Invalid ports specified.' if ports.empty?
+    ports
+  end
+
+  # Setter for the #http_ports attribute, will raise a BetterCap::Error if +value+
+  # is not a valid comma separated list of ports.
+  def http_ports=(value)
+    @http_ports = to_ports(value)
+  end
+
+  # Setter for the #https_ports attribute, will raise a BetterCap::Error if +value+
+  # is not a valid comma separated list of ports.
+  def https_ports=(value)
+    @https_ports = to_ports(value)
+  end
+
   # Split specified targets and parse them ( either as IP or MAC ), will raise a
   # BetterCap::Error if one or more invalid addresses are specified.
   def to_targets
@@ -430,35 +469,43 @@ class Options
     redirections = []
 
     if @proxy
-      redirections << Firewalls::Redirection.new( @iface,
-                                       'TCP',
-                                       80,
-                                       ifconfig[:ip_saddr],
-                                       @proxy_port )
+      @http_ports.each do |port|
+        redirections << Firewalls::Redirection.new( @iface,
+                                         'TCP',
+                                         port,
+                                         ifconfig[:ip_saddr],
+                                         @proxy_port )
+      end
     end
 
     if @proxy_https
-      redirections << Firewalls::Redirection.new( @iface,
-                                       'TCP',
-                                       443,
-                                       ifconfig[:ip_saddr],
-                                       @proxy_https_port )
+      @https_ports.each do |port|
+        redirections << Firewalls::Redirection.new( @iface,
+                                         'TCP',
+                                         port,
+                                         ifconfig[:ip_saddr],
+                                         @proxy_https_port )
+      end
     end
 
     if @custom_proxy
-      redirections << Firewalls::Redirection.new( @iface,
-                                       'TCP',
-                                       80,
-                                       @custom_proxy,
-                                       @custom_proxy_port )
+      @http_ports.each do |port|
+        redirections << Firewalls::Redirection.new( @iface,
+                                         'TCP',
+                                         port,
+                                         @custom_proxy,
+                                         @custom_proxy_port )
+      end
     end
 
     if @custom_https_proxy
-      redirections << Firewalls::Redirection.new( @iface,
-                                       'TCP',
-                                       443,
-                                       @custom_https_proxy,
-                                       @custom_https_proxy_port )
+      @https_ports.each do |port|
+        redirections << Firewalls::Redirection.new( @iface,
+                                         'TCP',
+                                         port,
+                                         @custom_https_proxy,
+                                         @custom_https_proxy_port )
+      end
     end
 
     redirections

data/lib/bettercap/proxy/module.rb

@@ -82,6 +82,8 @@ class Module
 
   private
 
+  # Loop each available BetterCap::Proxy::Proxy module and yield each
+  # one of them for the given code block.
   def self.each_module
     Object.constants.each do |klass|
       const = Kernel.const_get(klass)

data/lib/bettercap/proxy/modules/injectcss.rb

@@ -9,10 +9,15 @@ Blog   : http://www.evilsocket.net/
 This project is released under the GPL 3 license.
 
 =end
+
+# This proxy module will take care of CSS code injection.
 class Injectcss < BetterCap::Proxy::Module
+  # CSS data to be injected.
   @@cssdata = nil
+  # CSS file URL to be injected.
   @@cssurl  = nil
 
+  # Add custom command line arguments to the +opts+ OptionParser instance.
   def self.on_options(opts)
     opts.separator ""
     opts.separator "Inject CSS Proxy Module Options:"
@@ -20,7 +25,7 @@ class Injectcss < BetterCap::Proxy::Module
 
     opts.on( '--css-data STRING', 'CSS code to be injected.' ) do |v|
       @@cssdata = v
-      unless @@jsdata.include?("<style>")
+      unless @@cssdata.include?("<style>")
         @@cssdata = "<style>\n#{@@cssdata}\n</style>"
       end
     end
@@ -39,21 +44,24 @@ class Injectcss < BetterCap::Proxy::Module
     end
   end
 
+  # Create an instance of this module and raise a BetterCap::Error if command
+  # line arguments weren't correctly specified.
+  def initialize
+    raise BetterCap::Error, "No --css-file, --css-url or --css-data options specified for the proxy module." if @@cssdata.nil? and @@cssurl.nil?
+  end
+
+  # Called by the BetterCap::Proxy::Proxy processor on each HTTP +request+ and
+  # +response+.
   def on_request( request, response )
     # is it a html page?
     if response.content_type =~ /^text\/html.*/
-      # check command line arguments.
-      if @@cssdata.nil? and @@cssurl.nil?
-        BetterCap::Logger.warn "No --css-file or --css-url options specified, this proxy module won't work."
+      BetterCap::Logger.info "Injecting CSS #{if @@cssdata.nil? then "URL" else "file" end} into http://#{request.host}#{request.url}"
+      # inject URL
+      if @@cssdata.nil?
+        response.body.sub!( '</head>', "  <link rel=\"stylesheet\" href=\"#{@cssurl}\"></script></head>" )
+      # inject data
       else
-        BetterCap::Logger.info "Injecting CSS #{if @@cssdata.nil? then "URL" else "file" end} into http://#{request.host}#{request.url}"
-        # inject URL
-        if @@cssdata.nil?
-          response.body.sub!( '</head>', "  <link rel=\"stylesheet\" href=\"#{@cssurl}\"></script></head>" )
-        # inject data
-        else
-          response.body.sub!( '</head>', "#{@@cssdata}</head>" )
-        end
+        response.body.sub!( '</head>', "#{@@cssdata}</head>" )
       end
     end
   end

data/lib/bettercap/proxy/modules/injectjs.rb

@@ -9,10 +9,15 @@ Blog   : http://www.evilsocket.net/
 This project is released under the GPL 3 license.
 
 =end
+
+# This proxy module will take care of Javascript code injection.
 class Injectjs < BetterCap::Proxy::Module
+  # JS data to be injected.
   @@jsdata = nil
+  # JS file URL to be injected.
   @@jsurl  = nil
 
+  # Add custom command line arguments to the +opts+ OptionParser instance.
   def self.on_options(opts)
     opts.separator ""
     opts.separator "Inject JS Proxy Module Options:"
@@ -39,21 +44,24 @@ class Injectjs < BetterCap::Proxy::Module
     end
   end
 
+  # Create an instance of this module and raise a BetterCap::Error if command
+  # line arguments weren't correctly specified.
+  def initialize
+    raise BetterCap::Error, "No --js-file, --js-url or --js-data options specified for the proxy module." if @@jsdata.nil? and @@jsurl.nil?
+  end
+
+  # Called by the BetterCap::Proxy::Proxy processor on each HTTP +request+ and
+  # +response+.
   def on_request( request, response )
     # is it a html page?
     if response.content_type =~ /^text\/html.*/
-      # check command line arguments.
-      if @@jsdata.nil? and @@jsurl.nil?
-        BetterCap::Logger.warn "No --js-file or --js-url options specified, this proxy module won't work."
+      BetterCap::Logger.info "Injecting javascript #{if @@jsdata.nil? then "URL" else "file" end} into http://#{request.host}#{request.url}"
+      # inject URL
+      if @@jsdata.nil?
+        response.body.sub!( '</head>', "<script src=\"#{@@jsurl}\" type=\"text/javascript\"></script></head>" )
+      # inject data
       else
-        BetterCap::Logger.info "Injecting javascript #{if @@jsdata.nil? then "URL" else "file" end} into http://#{request.host}#{request.url}"
-        # inject URL
-        if @@jsdata.nil?
-          response.body.sub!( '</head>', "<script src=\"#{@@jsurl}\" type=\"text/javascript\"></script></head>" )
-        # inject data
-        else
-          response.body.sub!( '</head>', "#{@@jsdata}</head>" )
-        end
+        response.body.sub!( '</head>', "#{@@jsdata}</head>" )
       end
     end
   end

data/lib/bettercap/proxy/proxy.rb

@@ -87,6 +87,8 @@ class Proxy
 
   private
 
+  # Main server thread, will accept incoming connections and push them to
+  # the thread pool.
   def server_thread
     Logger.info "#{@type} Proxy started on #{@address}:#{@port} ...\n"
 
@@ -103,100 +105,31 @@ class Proxy
     @socket.close unless @socket.nil?
   end
 
+  # Return true if the +request+ host header contains one of this computer
+  # ip addresses.
   def is_self_request?(request)
     @local_ips.include? IPSocket.getaddress(request.host)
   end
 
-  def create_upstream_connection( request )
-    sock = TCPSocket.new( request.host, request.port )
-
-    if @is_https
-      ctx = OpenSSL::SSL::SSLContext.new
-      # do we need this? :P ctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
-
-      sock = OpenSSL::SSL::SSLSocket.new(sock, ctx).tap do |socket|
-        sock.sync_close = true
-        sock.connect
-      end
-    end
-
-    sock
-  end
-
-  def get_client_details( client )
-    unless @is_https
-      client_port, client_ip = Socket.unpack_sockaddr_in(client.getpeername)
-    else
-      _, client_port, _, client_ip = client.peeraddr
-    end
-
-    [ client_ip, client_port ]
-  end
-
+  # Handle a new +client+.
   def client_worker( client )
-    client_ip, client_port = get_client_details client
-
-    Logger.debug "New #{@type} connection from #{client_ip}:#{client_port}"
-
-    server = nil
     request = Request.new @is_https ? 443 : 80
 
     begin
       Logger.debug 'Reading request ...'
 
-      request.read client
+      request.read(client)
 
       # someone is having fun with us =)
       if is_self_request? request
-
-        Logger.warn "#{client_ip} is connecting to us directly."
-
         @streamer.rickroll client
-
-      elsif request.verb == 'CONNECT'
-
-        Logger.error "You're using bettercap as a normal HTTP(S) proxy, it wasn't designed to handle CONNECT requests:\n\n#{request.to_s}"
-
+      # handle request
       else
-
-        Logger.debug 'Creating upstream connection ...'
-
-        server = create_upstream_connection request
-
-        sreq = request.to_s
-
-        Logger.debug "Sending request:\n#{sreq}"
-
-        server.write sreq
-
-        # this is probably a POST request, collect incoming data
-        if request.content_length > 0
-          Logger.debug "Getting #{request.content_length} bytes from client"
-
-          @streamer.binary client, server, request: request
-        end
-
-        Logger.debug 'Reading response ...'
-
-        response = Response.from_socket server
-
-        if response.textual?
-          StreamLogger.log_http( @is_https, client_ip, request, response )
-
-          Logger.debug 'Detected textual response'
-
-          @streamer.html request, response, server, client
-        else
-          Logger.debug "[#{client_ip}] -> #{request.host}#{request.url} [#{response.code}]"
-
-          Logger.debug 'Binary streaming'
-
-          @streamer.binary server, client, response: response
-        end
-
-        Logger.debug "#{@type} client served."
+        @streamer.handle( request, client, @is_https )
       end
 
+      Logger.debug "#{@type} client served."
+
     rescue Exception => e
       if request.host
         Logger.warn "Error while serving #{request.host}#{request.url}: #{e.inspect}"
@@ -205,7 +138,6 @@ class Proxy
     end
 
     client.close
-    server.close unless server.nil?
   end
 end
 

data/lib/bettercap/proxy/request.rb

@@ -24,8 +24,12 @@ class Request
   attr_reader :host
   # Request port.
   attr_reader :port
+  # Request headers hash.
+  attr_reader :headers
   # Content length.
   attr_reader :content_length
+  # Request body.
+  attr_reader :body
 
   # Initialize this object setting #port to +default_port+.
   def initialize( default_port = 80 )
@@ -34,7 +38,9 @@ class Request
     @url    = nil
     @host   = nil
     @port   = default_port
+    @headers = {}
     @content_length = 0
+    @body   = nil
   end
 
   # Read lines from the +sock+ socket and parse them.
@@ -53,6 +59,11 @@ class Request
     end
 
     raise "Couldn't extract host from the request." unless @host
+
+    # keep reading the request body if needed
+    if @content_length > 0
+      @body = sock.read(@content_length)
+    end
   end
 
   # Parse a single request line, patch it if needed and append it to #lines.
@@ -93,6 +104,11 @@ class Request
       line = 'Accept-Encoding: identity'
     end
 
+    # collect headers
+    if line =~ /^([^:\s]+)\s*:\s*(.+)$/i
+      @headers[$1] = $2
+    end
+
     @lines << line
   end
 
@@ -103,7 +119,7 @@ class Request
 
   # Return a string representation of the HTTP request.
   def to_s
-    @lines.join("\n") + "\n"
+    @lines.join("\n") + "\n" + ( @body || '' )
   end
 end
 end

data/lib/bettercap/proxy/response.rb

@@ -25,7 +25,7 @@ class Response
   # A list of response headers.
   attr_reader :headers
   # Response status code.
-  attr_reader :code
+  attr_accessor :code
   # True if the parser finished to parse the headers, otherwise false.
   attr_reader :headers_done
   # Response body.
@@ -43,21 +43,15 @@ class Response
     @chunked = false
   end
 
-  # Read lines from the +sock+ socket until all headers are correctly parsed
-  # and return a BetterCap::Proxy::Response instance.
-  def self.from_socket(sock)
-    response = Response.new
-
-    # read all response headers
-    loop do
-      line = sock.readline
-
-      response << line
-
-      break unless not response.headers_done
+  # Convert a webrick response to this class.
+  def convert_webrick_response!(response)
+    self << "HTTP/#{response.http_version} #{response.code} #{response.msg}"
+    response.each do |key,value|
+      self << "#{key}: #{value}"
     end
-
-    response
+    self << "\n"
+    @code = response.code
+    @body = response.body || ''
   end
 
   # Parse a single response +line+.

data/lib/bettercap/proxy/streamer.rb

@@ -15,9 +15,6 @@ module BetterCap
 module Proxy
 # Handle data streaming between clients and servers for the BetterCap::Proxy::Proxy.
 class Streamer
-  # Default buffer size for data streaming.
-  BUFSIZE = 1024 * 16
-
   # Initialize the class with the given +processor+ routine.
   def initialize( processor )
     @processor = processor
@@ -25,155 +22,89 @@ class Streamer
 
   # Redirect the +client+ to a funny video.
   def rickroll( client )
+    Logger.warn "#{client_ip} is connecting to us directly."
+
     client.write "HTTP/1.1 302 Found\n"
     client.write "Location: https://www.youtube.com/watch?v=dQw4w9WgXcQ\n\n"
   end
 
-  # Perform HTML streaming for the given +request+, applying the #processor
-  # to the +response+.
-  # +from+ and +to+ are the two TCP endpoints.
-  def html( request, response, from, to )
-    buff = ''
-
-    if response.chunked
-      Logger.debug "Reading response body using chunked encoding ..."
-
-      begin
-        len = nil
-        total = 0
-
-        while true
-          line = from.readline
-          hexlen = line.slice(/[0-9a-fA-F]+/) or raise "Wrong chunk size line: #{line}"
-          len = hexlen.hex
-          break if len == 0
-          begin
-            Logger.debug "Reading chunk of size #{len} ..."
-            tmp = read( from, len )
-            Logger.debug "Read #{tmp.bytesize}/#{len} chunk."
-            response << tmp
-          ensure
-            total += len
-            from.read 2
-          end
-        end
-
-      rescue Exception => e
-        Logger.debug e
-      end
-
-    elsif response.content_length.nil?
-      Logger.debug "Reading response body using 1024 bytes chunks ..."
+  # Handle the HTTP +request+ from +client+, if +is_https+ is true it will be
+  # forwarded as a HTTPS request.
+  def handle( request, client, is_https )
+    response = Response.new
+    client_ip, client_port = get_client_details( is_https, client )
 
-      loop do
-        buff = read( from, 1024 )
+    Logger.debug "Handling #{request.verb} request from #{client_ip}:#{client_port} ..."
 
-        break unless buff.size > 0
+    begin
+      self.send( "do_#{request.verb}", request, response )
 
-        response << buff
+      if response.textual?
+        StreamLogger.log_http( is_https, client_ip, request, response )
+      else
+        Logger.debug "[#{client_ip}] -> #{request.host}#{request.url} [#{response.code}]"
       end
-    else
-      Logger.debug "Reading response body using #{response.content_length} bytes buffer ..."
-
-      buff = read( from, response.content_length )
 
-      Logger.debug "Read #{buff.size} / #{response.content_length} bytes."
+      @processor.call( request, response )
 
-      response << buff
+      client.write response.to_s
+    rescue NoMethodError
+      Logger.warn "Could not handle #{request.verb} request from #{client_ip}:#{client_port} ..."
     end
-
-    @processor.call( request, response )
-
-    # Response::to_s will patch the headers if needed
-    to.write response.to_s
   end
 
-  # Perform binary streaming using the +opts+ dictionary.
-  # If response|request object is available inside +opts+ and a content length
-  # as well use it to speed up data streaming with precise data size
-  # +from+ and +to+ are the two TCP endpoints.
-  def binary( from, to, opts = {} )
-    total_size = 0
-
-    if not opts[:response].nil?
-      to.write opts[:response].to_s
-
-      total_size = opts[:response].content_length unless opts[:response].content_length.nil?
-    elsif not opts[:request].nil?
-
-      total_size = opts[:request].content_length unless opts[:request].content_length.nil?
-    end
-
-    buff = ''
-    read = 0
+  private
 
-    if total_size
-      chunk_size = [ 1024, total_size ].min
+  # Return the +client+ ip address and port.
+  def get_client_details( is_https, client )
+    unless is_https
+      client_port, client_ip = Socket.unpack_sockaddr_in(client.getpeername)
     else
-      chunk_size = 1024
+      _, client_port, _, client_ip = client.peeraddr
     end
 
-    if chunk_size > 0
-      loop do
-        buff = read( from, chunk_size )
+    [ client_ip, client_port ]
+  end
 
-        # nothing more to read?
-        break unless buff.size > 0
+  # Use a Net::HTTP object in order to perform the +req+ BetterCap::Proxy::Request
+  # object, will return a BetterCap::Proxy::Response object instance.
+  def perform_proxy_request(req, res)
+    path         = req.url
+    response     = nil
+    http         = Net::HTTP.new( req.host, req.port )
+    http.use_ssl = ( req.port == 443 )
 
-        to.write buff
+    http.start do
+      response = yield( http, path, req.headers )
+    end
 
-        read += buff.size
+    res.convert_webrick_response!(response)
+  end
 
-        # collect into the proper object
-        if not opts[:request].nil? and opts[:request].post?
-          opts[:request] << buff
-        end
+  # Handle a CONNECT request, +req+ is the request object and +res+ the response.
+  def do_CONNECT(req, res)
+    Logger.error "You're using bettercap as a normal HTTP(S) proxy, it wasn't designed to handle CONNECT requests:\n\n#{req.to_s}"
+  end
 
-        # we've done reading?
-        break unless read != total_size
-      end
+  # Handle a GET request, +req+ is the request object and +res+ the response.
+  def do_GET(req, res)
+    perform_proxy_request(req, res) do |http, path, header|
+      http.get(path, header)
     end
   end
 
-  private
-
-  def consume_stream io, size
-    read_timeout = 60.0
-    dest = ''
-    begin
-      dest << io.read_nonblock(size)
-    rescue IO::WaitReadable
-      if IO.select([io], nil, nil, read_timeout)
-        retry
-      else
-        raise Net::ReadTimeout
-      end
-    rescue IO::WaitWritable
-      # OpenSSL::Buffering#read_nonblock may fail with IO::WaitWritable.
-      # http://www.openssl.org/support/faq.html#PROG10
-      if IO.select(nil, [io], nil, read_timeout)
-        retry
-      else
-        raise Net::ReadTimeout
-      end
+  # Handle a HEAD request, +req+ is the request object and +res+ the response.
+  def do_HEAD(req, res)
+    perform_proxy_request(req, res) do |http, path, header|
+      http.head(path, header)
     end
-    dest
   end
 
-  def read( sd, size )
-    buffer = ''
-    begin
-      while size > 0
-        tmp = consume_stream sd, [ BUFSIZE, size ].min
-        unless tmp.nil? or tmp.bytesize == 0
-          buffer << tmp
-          size -= tmp.bytesize
-        end
-      end
-    rescue EOFError
-      ;
+  # Handle a POST request, +req+ is the request object and +res+ the response.
+  def do_POST(req, res)
+    perform_proxy_request(req, res) do |http, path, header|
+      http.post(path, req.body || "", header)
     end
-    buffer
   end
 
 end

data/lib/bettercap/sniffer/sniffer.rb

@@ -52,6 +52,7 @@ class Sniffer
 
   private
 
+  # Return the current PCAP stream.
   def self.stream
     if @@ctx.options.sniffer_src.nil?
       @@cap.stream
@@ -62,12 +63,14 @@ class Sniffer
     end
   end
 
+  # Return true if the +pkt+ packet instance must be skipped.
   def self.skip_packet?( pkt )
     !@@ctx.options.local and
         ( pkt.ip_saddr == @@ctx.ifconfig[:ip_saddr] or
             pkt.ip_daddr == @@ctx.ifconfig[:ip_saddr] )
   end
 
+  # Apply each parser on the given +parsed+ packet.
   def self.parse_packet( parsed )
     @@parsers.each do |parser|
       begin
@@ -78,6 +81,7 @@ class Sniffer
     end
   end
 
+  # Append the packet +p+ to the current PCAP file.
   def self.append_packet( p )
     begin
       @@pcap.array_to_file(
@@ -89,6 +93,7 @@ class Sniffer
     end
   end
 
+  # Setup all needed objects for the sniffer using the +ctx+ Context instance.
   def self.setup( ctx )
     @@ctx = ctx
 

data/lib/bettercap/spoofers/arp.rb

@@ -80,37 +80,51 @@ class Arp < Base
 
     @ctx.targets.each do |target|
       unless target.ip.nil? or target.mac.nil?
-        begin
-          send_spoofed_packet( @gateway.ip, @gateway.mac, target.ip, target.mac )
-          send_spoofed_packet( target.ip, target.mac, @gateway.ip, @gateway.mac ) unless @ctx.options.half_duplex
-        rescue; end
+        spoof(target)
       end
     end
   end
 
   private
 
+  # Send an ARP spoofing packet to +target+, if +restore+ is true it will
+  # restore its ARP cache instead.
+  def spoof( target, restore = false )
+    if restore
+      send_spoofed_packet( @gateway.ip, @ctx.ifconfig[:eth_saddr], target.ip, target.mac )
+      send_spoofed_packet( target.ip, @ctx.ifconfig[:eth_saddr], @gateway.ip, @gateway.mac ) unless @ctx.options.half_duplex
+    else
+      send_spoofed_packet( @gateway.ip, @gateway.mac, target.ip, target.mac )
+      send_spoofed_packet( target.ip, target.mac, @gateway.ip, @gateway.mac ) unless @ctx.options.half_duplex
+    end
+  end
+
+  # Main spoofer loop.
   def arp_spoofer
     spoof_loop(1) { |target|
       unless target.ip.nil? or target.mac.nil?
-        send_spoofed_packet( @gateway.ip, @ctx.ifconfig[:eth_saddr], target.ip, target.mac )
-        send_spoofed_packet( target.ip, @ctx.ifconfig[:eth_saddr], @gateway.ip, @gateway.mac ) unless @ctx.options.half_duplex
+        spoof(target, true)
       end
     }
   end
 
+  # Return true if the +pkt+ packet is an ARP 'who-has' query coming
+  # from some network endpoint.
+  def is_arp_query?(pkt)
+    # we're only interested in 'who-has' packets
+    pkt.arp_opcode == 1 and \
+    pkt.arp_dst_mac.to_s == '00:00:00:00:00:00' and \
+    pkt.arp_src_ip.to_s != @ctx.ifconfig[:ip_saddr]
+  end
+
+  # Will watch for incoming ARP requests and spoof the source address.
   def arp_watcher
     Logger.debug 'ARP watcher started ...'
 
     sniff_packets('arp') { |pkt|
-      # we're only interested in 'who-has' packets
-      if pkt.arp_opcode == 1 and pkt.arp_dst_mac.to_s == '00:00:00:00:00:00'
-        is_from_us = ( pkt.arp_src_ip.to_s == @ctx.ifconfig[:ip_saddr] )
-        unless is_from_us
-          Logger.info "[ARP] #{pkt.arp_src_ip.to_s} is asking who #{pkt.arp_dst_ip.to_s} is."
-
-          send_spoofed_packet pkt.arp_dst_ip.to_s, @ctx.ifconfig[:eth_saddr], pkt.arp_src_ip.to_s, pkt.arp_src_mac.to_s
-        end
+      if is_arp_query?(pkt)
+        Logger.info "[#{'ARP'.green}] #{pkt.arp_src_ip.to_s} is asking who #{pkt.arp_dst_ip.to_s} is."
+        send_spoofed_packet pkt.arp_dst_ip.to_s, @ctx.ifconfig[:eth_saddr], pkt.arp_src_ip.to_s, pkt.arp_src_mac.to_s
       end
     }
   end

data/lib/bettercap/spoofers/base.rb

@@ -28,6 +28,8 @@ class Base
 
 private
 
+  # Will create a PacketFu::Capture object using the specified +filter+ and
+  # will yield every parsed packet to the given code block.
   def sniff_packets( filter )
     begin
       @capture = PacketFu::Capture.new(
@@ -57,21 +59,49 @@ private
     end
   end
 
+  # Print informations about new and lost targets.
+  def print_differences( prev_targets )
+    size      = @ctx.targets.size
+    prev_size = prev_targets.size
+    diff      = nil
+    label     = nil
+
+    if size > prev_size
+      diff  = @ctx.targets - prev_targets
+      delta = diff.size
+      label = 'NEW'.green
+
+      Logger.warn "Acquired #{delta} new target#{if delta > 1 then "s" else "" end}."
+    elsif size < prev_size
+      diff  = prev_targets - @ctx.targets
+      delta = diff.size
+      label = 'LOST'.red
+
+      Logger.warn "Lost #{delta} target#{if delta > 1 then "s" else "" end}."
+    end
+
+    unless diff.nil?
+      msg = "\n"
+      diff.each do |target|
+        msg += "  [#{label}] #{target.to_s(false)}\n"
+      end
+      msg += "\n"
+      Logger.raw msg
+    end
+  end
+
+  # Main spoof loop repeated each +delay+ seconds.
   def spoof_loop( delay )
-    prev_size = @ctx.targets.size
+    prev_targets = @ctx.targets
+
     loop do
-      if not @running
+      unless @running
           Logger.debug 'Stopping spoofing thread ...'
           Thread.exit
           break
       end
 
-      size = @ctx.targets.size
-      if size > prev_size
-        Logger.warn "Aquired #{size - prev_size} new targets."
-      elsif size < prev_size
-        Logger.warn "Lost #{prev_size - size} targets."
-      end
+      print_differences prev_targets
 
       Logger.debug "Spoofing #{@ctx.targets.size} targets ..."
 
@@ -81,12 +111,13 @@ private
         yield(target)
       end
 
-      prev_size = @ctx.targets.size
+      prev_targets = @ctx.targets
 
       sleep(delay)
     end
   end
 
+  # Get the MAC address of the gateway and update it.
   def update_gateway!
     hw = Network.get_hw_address( @ctx.ifconfig, @ctx.gateway )
     raise BetterCap::Error, "Couldn't determine router MAC" if hw.nil?
@@ -95,6 +126,7 @@ private
     Logger.info "[#{'GATEWAY'.green}] #{@gateway.to_s(false)}"
   end
 
+  # Update each target that needs to be updated.
   def update_targets!
     @ctx.targets.each do |target|
       # targets could change, update mac addresses if needed
@@ -122,6 +154,7 @@ private
     end
   end
 
+  # Used to raise a NotImplementedError exception.
   def not_implemented_method!
     raise NotImplementedError, 'Spoofers::Base: Unimplemented method!'
   end

data/lib/bettercap/spoofers/icmp.rb

@@ -30,6 +30,7 @@ class ICMPRedirectPacket < PacketFu::Packet
 
     attr_accessor :eth_header, :ip_header, :icmp_header, :ip_encl_header
 
+    # Create a ICMPRedirectPacket instance.
     def initialize(args={})
       @eth_header = PacketFu::EthHeader.new(args).read(args[:eth])
 
@@ -54,6 +55,8 @@ class ICMPRedirectPacket < PacketFu::Packet
       super
     end
 
+    # Update this packet with the correct +gateway+, +target+, +local+ address
+    # and +address2redirect+.
     def update!( gateway, target, local, address2redirect )
       @eth_header.eth_src = PacketFu::EthHeader.mac2str(gateway.mac)
       @ip_header.ip_saddr = gateway.ip
@@ -145,6 +148,7 @@ class Icmp < Base
 
   private
 
+  # Return true if the +pkt+ packet comes from one of our targets.
   def is_interesting_packet?(pkt)
     return false if pkt.ip_saddr == @local
     @ctx.targets.each do |target|
@@ -155,6 +159,7 @@ class Icmp < Base
     false
   end
 
+  # DNS watcher logic.
   def dns_watcher
     Logger.debug 'DNS watcher started ...'
 
@@ -188,6 +193,7 @@ class Icmp < Base
     }
   end
 
+  # Main spoofer loop.
   def icmp_spoofer
     spoof_loop(3) { |target|
       unless target.ip.nil? or target.mac.nil?

data/lib/bettercap/spoofers/none.rb

@@ -19,13 +19,41 @@ class None < Base
   # Initialize the non-spoofing class.
   def initialize
     Logger.warn 'Spoofing disabled.'
+
+    @ctx     = Context.get
+    @gateway = nil
+    @thread  = nil
+    @running = false
+
+    update_gateway!
+  end
+
+  # Start the "NONE" spoofer.
+  def start
+    stop() if @running
+    @running = true
+
+    @thread = Thread.new { fake_spoofer }
   end
 
-  # This does nothing.
-  def start; end
+  # Stop the "NONE" spoofer.
+  def stop
+    return unless @running
+
+    @running = false
+    begin
+      @thread.exit
+    rescue
+    end
+  end
+
+  private
+
+  # Main fake spoofer loop.
+  def fake_spoofer
+    spoof_loop(1) { |target| }
+  end
 
-  # This does nothing.
-  def stop; end
 end
 end
 end

data/lib/bettercap/version.rb

@@ -11,7 +11,7 @@ This project is released under the GPL 3 license.
 =end
 module BetterCap
   # Current version of bettercap.
-  VERSION = '1.2.2'
+  VERSION = '1.2.3'
   # Program banner.
   BANNER = File.read( File.dirname(__FILE__) + '/banner' ).gsub( '#VERSION#', "v#{VERSION}")
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bettercap
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - Simone Margaritelli
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-16 00:00:00.000000000 Z
+date: 2016-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize