wpxf 2.0.0a

data/lib/wpxf/net/http_response.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Wpxf
+  module Net
+    # A response from a request made by a HttpClient.
+    class HttpResponse
+      # @param res [Object] a response to parse.
+      def initialize(res)
+        parse_typhoeus_response(res) if res.is_a? Typhoeus::Response
+      end
+
+      # Parse a Typhoeus response into the object.
+      # @param res [Typhoeus::Response] the response object to parse.
+      # @return [nil]
+      def parse_typhoeus_response(res)
+        self.code = res.code
+        self.body = res.body.nil? ? '' : res.body
+        self.headers = res.headers
+        self.timed_out = res.timed_out? || res.return_code == :couldnt_connect
+        self.cookies = CookieJar.new.parse(res.headers['Set-Cookie']) if res.headers
+      end
+
+      # @return [Boolean] a boolean that indicates whether a request timed out.
+      def timed_out?
+        timed_out
+      end
+
+      # @return [Integer] the HTTP status code.
+      attr_accessor :code
+
+      # @return [String] the response body.
+      attr_accessor :body
+
+      # @return [Hash] a hash of all returned headers.
+      attr_accessor :headers
+
+      # @return [Boolean] a boolean that indicates whether a request timed out.
+      attr_accessor :timed_out
+
+      # @return [Hash] a {CookieJar} with all returned cookies.
+      attr_accessor :cookies
+    end
+  end
+end

data/lib/wpxf/net/http_server.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'socket'
+
+# Provides basic, single threaded HTTP server functionality.
+module Wpxf::Net::HttpServer
+  include Wpxf
+
+  # Initialize a new instance of {HttpServer}.
+  def initialize
+    super
+
+    register_options([
+      StringOption.new(
+        name: 'http_server_bind_address',
+        desc: 'Address to bind the HTTP server to',
+        default: '0.0.0.0',
+        required: true
+      ),
+      PortOption.new(
+        name: 'http_server_bind_port',
+        desc: 'Port for the HTTP server to listen on',
+        default: 80,
+        required: true
+      )
+    ])
+
+    @http_server_kill_switch = false
+  end
+
+  # @return [String] the address the HTTP server is bound to.
+  def http_server_bind_address
+    normalized_option_value('http_server_bind_address')
+  end
+
+  # @return [Integer] the port the HTTP server is listening on.
+  def http_server_bind_port
+    normalized_option_value('http_server_bind_port')
+  end
+
+  # Invoked when a HTTP request is made to the server.
+  # @param path [String] the path requested.
+  # @param params [Hash] the query string parameters.
+  # @param headers [Hash] the HTTP headers.
+  # @return [String, Hash] if a string is returned, it will be used as the response body
+  #  to send to the client. If a hash is returned, it should contain the keys:
+  #  * +:body+ - the body text of the response.
+  #  * +:type+ - the MIME type of the response.
+  #  * +:headers+ - an array of header strings.
+  def on_http_request(path, params, headers) end
+
+  # @return [String] the AJAX download helper script.
+  def js_ajax_download
+    File.read(File.join(Wpxf.data_directory, 'js', 'ajax_download.js'))
+  end
+
+  # @return [String] the AJAX post helper script.
+  def js_ajax_post
+    File.read(File.join(Wpxf.data_directory, 'js', 'ajax_post.js'))
+  end
+
+  # @return [String] the JS post helper script.
+  def js_post
+    File.read(File.join(Wpxf.data_directory, 'js', 'post.js'))
+  end
+
+  # Start the HTTP server.
+  # @param non_block [Boolean] run the server in non-blocking mode.
+  def start_http_server(non_block = false)
+    @tcp_server = TCPServer.new(http_server_bind_address, http_server_bind_port)
+    emit_info "Started HTTP server on #{http_server_bind_address}:"\
+              "#{http_server_bind_port}"
+
+    if non_block
+      @http_server_thread = Thread.new do
+        _http_server_loop
+      end
+    else
+      _http_server_loop
+    end
+  end
+
+  # Stop the HTTP server after it has finished processing the current request.
+  def stop_http_server
+    return false if @is_stopping
+    @is_stopping = true
+
+    emit_info 'Stopping HTTP server...', true
+    @http_server_kill_switch = true
+    @http_server_thread&.exit
+    @tcp_server.close if !@tcp_server.nil? && !@tcp_server.closed?
+    emit_info 'HTTP server stopped'
+    @is_stopping = false
+  end
+
+  # @return [Thread] thread that the server runs on when in non-blocking mode.
+  def http_server_thread
+    @http_server_thread
+  end
+
+  private
+
+  def _send_headers(socket, body, content_type, custom_headers)
+    headers = []
+    headers.push 'HTTP/1.1 200 OK'
+    headers.push "Content-Type: #{content_type}"
+    headers.push "Content-Length: #{body.bytesize}"
+    headers += custom_headers unless custom_headers.nil?
+    headers.push 'Connection: close'
+
+    headers.each do |header|
+      socket.print "#{header}\r\n"
+    end
+  end
+
+  def _send_response(response, socket)
+    content_type = 'text/plain'
+    body = ''
+    custom_headers = nil
+
+    if response.is_a? String
+      body = response
+    else
+      body = response[:body]
+      content_type = response[:type]
+      custom_headers = response[:headers]
+    end
+
+    _send_headers(socket, body, content_type, custom_headers)
+    socket.print "\r\n"
+    socket.print body
+  end
+
+  def _http_server_loop
+    begin
+      loop do
+        socket = @tcp_server.accept
+
+        begin
+          response = _handle_incoming_http_request(socket)
+          _send_response(response, socket) if response
+          socket.close
+        rescue Errno::EPIPE
+          emit_warning 'A socket was closed by the requester', true
+        end
+
+        break if @http_server_kill_switch
+      end
+    rescue SignalException
+      emit_warning 'Caught kill signal', true
+    rescue StandardError => e
+      emit_error "Socket error: #{e}"
+    end
+
+    stop_http_server
+  end
+
+  def _handle_incoming_http_request(socket)
+    request = socket.gets
+    return unless request
+
+    emit_info "Incoming HTTP request: #{request}", true
+
+    headers = ''
+    while (line = socket.gets) != "\r\n"
+      headers += line
+      emit_info line, true
+    end
+
+    headers = Hash[headers.each_line.map { |l| l.chomp.split(': ', 2) }]
+    path = request.gsub(/^[A-Za-z]+\s(.+?)\s.*$/, '\1').chomp
+    params = {}
+
+    if path.include?('?')
+      params = CGI.parse(path.split('?')[-1])
+      params.each do |k, v|
+        params[k] = v.join(' ')
+      end
+      path = path.split('?')[0]
+    end
+
+    # Dispatch parsed data to the callback in the module.
+    on_http_request(path, params, headers)
+  end
+end

data/lib/wpxf/net/typhoeus_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Wpxf
+  module Net
+    # Provides helper functions for interfacing with Typhoeus in a module.
+    module TyphoeusHelper
+      def advanced_typhoeus_options
+        {
+          userpwd: datastore['basic_auth_creds'],
+          proxy: datastore['proxy'],
+          proxyuserpwd: datastore['proxy_auth_creds'],
+          ssl_verifyhost: normalized_option_value('verify_host') ? 2 : 0,
+          ssl_verifypeer: normalized_option_value('verify_peer'),
+          timeout: normalized_option_value('http_client_timeout')
+        }
+      end
+
+      def standard_typhoeus_options(method, params, body, headers)
+        {
+          method: method,
+          body: body,
+          params: params,
+          headers: base_http_headers.merge(headers),
+          followlocation: normalized_option_value('follow_http_redirection')
+        }
+      end
+
+      def create_typhoeus_request_options(method, params, body, headers)
+        standard_typhoeus_options(method, params, body, headers)
+          .merge(advanced_typhoeus_options)
+      end
+
+      def create_typhoeus_request(opts)
+        headers = opts[:headers] || {}
+        headers['Cookie'] = opts[:cookie] if opts[:cookie]
+        options = create_typhoeus_request_options(
+          opts[:method],
+          opts[:params],
+          opts[:body],
+          headers
+        )
+        Typhoeus::Request.new(normalize_relative_uri(opts[:url]), options)
+      end
+    end
+  end
+end

data/lib/wpxf/net/user_agent.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Wpxf
+  module Net
+    # Provides functionality for generating user agent strings.
+    module UserAgent
+      include Wpxf::Versioning::BrowserVersions
+      include Wpxf::Versioning::OSVersions
+
+      # A random browser and OS combination.
+      # @return [Hash] a hash containing a :browser and :os
+      def random_browser_and_os
+        frequencies = clients_by_frequency
+        target_frequency = rand(1..100)
+        sum = 0
+
+        frequencies.each do |browser_frequency, combinations|
+          sum += browser_frequency.to_i
+          next if target_frequency > sum
+
+          # This browser encompasses our target frequency, so reset the
+          # frequency sum and generate a new target frequency for the
+          # operating system selection.
+          target_frequency = rand(1..100)
+          sum = 0
+
+          # Once we find an OS that covers the target frequency, return
+          # the browser/OS combination.
+          combinations.each do |os_frequency, combo|
+            sum += os_frequency.to_i
+            if target_frequency <= sum
+              return {
+                browser: combo['browser'].to_sym,
+                os: combo['os'].to_sym
+              }
+            end
+          end
+        end
+
+        # This point should never be reached, as the frequencies should
+        # always total 100 and thus we should always retrieve a combo.
+        raise 'Browser and OS frequencies exceeded 100'
+      end
+
+      # @return [Hash] a hash of browser and OS combinations grouped by
+      #   frequencies drawn from real-world statistics.
+      def clients_by_frequency
+        json = Wpxf::DataFile.new('json', 'browser_usage_by_frequency.json').content
+        JSON.parse(json)
+      end
+
+      # A random date between two dates in a specific format.
+      # @param min the minimum date to return.
+      # @param max the maximum date to return.
+      # @param format the format string to use when formatting the date.
+      # @return [String] a formatted random date.
+      def random_time_string(min, max = Time.now.to_s, format = '%Y%m%d')
+        rand(Time.parse(min)..Time.parse(max)).strftime(format)
+      end
+
+      # A random CPU type.
+      # @param os the operating system that the CPU would be used with.
+      # @return [String] a random CPU type.
+      def random_processor_string(os)
+        return ['i686', 'x86_64'].sample if os == :linux
+        return ['Intel', 'PPC', 'U; Intel', 'U; PPC'].sample if os == :osx
+      end
+
+      # @return [String] a random Firefox version string.
+      def random_firefox_version_string
+        [
+          "Gecko/#{random_time_string('2011-01-01')} "\
+          "Firefox/#{rand(5..7)}.0",
+          "Gecko/#{random_time_string('2011-01-01')} "\
+          "Firefox/#{rand(5..7)}.0.1",
+          "Gecko/#{random_time_string('2010-01-01')} "\
+          "Firefox/3.6.#{rand(1..20)}",
+          "Gecko/#{random_time_string('2010-01-01')} "\
+          'Firefox/3.8'
+        ].sample
+      end
+
+      # A random Firefox platform string.
+      # @param os the operating system that Firefox would be running on.
+      # @return [String] a random Firefox platform string.
+      def random_firefox_platform_string(os)
+        version = random_firefox_version_string
+        cpu = random_processor_string(os)
+
+        if os == :linux
+          return "(X11; Linux #{cpu}; rv:#{rand(5..7)}.0) #{version}"
+        end
+
+        if os == :osx
+          return "(Macintosh; #{cpu} Mac OS X #{random_osx_version} "\
+                 "rv:#{rand(2..6)}.0) #{version}"
+        end
+
+        if os == :windows
+          return "(Windows NT #{random_nt_version}; en-US; rv:1.9."\
+                 "#{rand(0..2)}.20) #{version}"
+        end
+      end
+
+      # A random Safari platform string.
+      # @param os the operating system that Safari would be running on.
+      # @return [String] a random Safari platform string.
+      def random_safari_platform_string(os)
+        build = random_safari_build_number
+        cpu = random_processor_string(os)
+        version = random_safari_version
+
+        if os == :osx
+          return "(Macintosh; U; #{cpu} Mac OS X #{random_osx_version} rv:"\
+                 "#{rand(2..6)}.0; en-US) AppleWebKit/#{build} "\
+                 "(KHTML, like Gecko) Version/#{version} Safari/#{build}"
+        else
+          return "(Windows; U; Windows NT #{random_nt_version}) AppleWebKit/"\
+                 "#{build} (KHTML, like Gecko) Version/#{version} "\
+                 "Safari/#{build}"
+        end
+      end
+
+      # A random Internet Explorer platform string.
+      # @return [String] a random Internet Explorer platform string.
+      def random_iexplorer_platform_string
+        "(compatible; MSIE #{random_ie_version}; Windows NT "\
+        "#{random_nt_version}; Trident/#{random_trident_version})"
+      end
+
+      # A random Opera platform string.
+      # @param os the operating system that Opera would be running on.
+      # @return [String] a random Opera platform string.
+      def random_opera_platform_string(os)
+        cpu = random_processor_string(os)
+        presto = random_presto_version
+        version = random_presto_version2
+
+        if os == :linux
+          return "(X11; Linux #{cpu}; U; en-US) Presto/#{presto} "\
+                 "Version/#{version}"
+        else
+          return "(Windows NT #{random_nt_version}; U; en-US) "\
+                 "Presto/#{presto} Version/#{version}"
+        end
+      end
+
+      # A random Chrome platform string.
+      # @param os the operating system that Chrome would be running on.
+      # @return [String] a random Chrome platform string.
+      def random_chrome_platform_string(os)
+        cpu = random_processor_string(os)
+        build = random_chrome_build_number
+        version = random_chrome_version
+
+        if os == :linux
+          return "(X11; Linux #{cpu}) AppleWebKit/#{build} (KHTML, like Gecko)"\
+                 " Chrome/#{version} Safari/#{build}"
+        end
+
+        if os == :osx
+          return "(Macintosh; U; #{cpu} Mac OS X #{random_osx_version}) "\
+                 "AppleWebKit/#{build} (KHTML, like Gecko) Chrome/"\
+                 "#{version} Safari/#{build}"
+        end
+
+        if os == :windows
+          return "(Windows NT #{random_nt_version}) AppleWebKit/#{build} "\
+                 "(KHTML, like Gecko) Chrome/#{version} Safari/#{build}"
+        end
+      end
+
+      # @return [String] a random browser user agent.
+      def random_user_agent
+        platform = random_browser_and_os
+        os = platform[:os]
+
+        if platform[:browser] == :firefox
+          return "Mozilla/5.0 #{random_firefox_platform_string(os)}"
+        elsif platform[:browser] == :safari
+          return "Mozilla/5.0 #{random_safari_platform_string(os)}"
+        elsif platform[:browser] == :iexplorer
+          return "Mozilla/5.0 #{random_iexplorer_platform_string}"
+        elsif platform[:browser] == :opera
+          return "Opera/#{random_opera_version} "\
+                 "#{random_opera_platform_string(os)}"
+        else
+          return "Mozilla/5.0 #{random_chrome_platform_string(os)}"
+        end
+      end
+    end
+  end
+end