ronin-web-server 0.1.0.beta1

data/lib/ronin/web/server/reverse_proxy/request.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+#
+# ronin-web-server - A custom Ruby web server based on Sinatra.
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-web-server is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-web-server is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-web-server.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/web/server/request'
+
+module Ronin
+  module Web
+    module Server
+      class ReverseProxy
+        #
+        # Class that represents a reverse proxied request.
+        #
+        class Request < Server::Request
+
+          #
+          # Changes the HTTP Host header of the request.
+          #
+          # @param [String] new_host
+          #   The new value of the HTTP Host header.
+          #
+          # @return [String]
+          #   The new HTTP Host header.
+          #
+          # @api public
+          #
+          def host=(new_host)
+            @env['HTTP_HOST'] = new_host
+          end
+
+          #
+          # Changes the port the request is being sent to.
+          #
+          # @param [Integer] new_port
+          #   The new port the request will be sent to.
+          #
+          # @return [Integer]
+          #   The new port the request will be sent to.
+          #
+          # @api public
+          #
+          def port=(new_port)
+            @env['SERVER_PORT'] = new_port
+          end
+
+          #
+          # Changes the URI scheme of the request.
+          #
+          # @param [String] new_scheme
+          #   The new URI scheme for the request.
+          #
+          # @return [String]
+          #   The new URI scheme of the request.
+          #
+          # @api public
+          #
+          def scheme=(new_scheme)
+            @env['rack.url_scheme'] = new_scheme
+          end
+
+          #
+          # Toggles whether the request to be proxied over SSL.
+          #
+          # @param [Boolean] ssl
+          #   Specifies whether to enable or disable SSL.
+          #
+          # @return [Boolean]
+          #   Whether SSL is enabled or disabled.
+          #
+          # @api public
+          #
+          def ssl=(ssl)
+            if ssl
+              self.port   = 443
+              self.scheme = 'https'
+            else
+              self.port   = 80
+              self.scheme = 'http'
+            end
+
+            return ssl
+          end
+
+          #
+          # Changes the HTTP Request Method of the request.
+          #
+          # @param [String] new_method
+          #   The new HTTP Request Method.
+          #
+          # @return [String]
+          #   The new HTTP Request Method.
+          #
+          # @api public
+          #
+          def request_method=(new_method)
+            @env['REQUEST_METHOD'] = new_method
+          end
+
+          #
+          # Changes the HTTP Query String of the request.
+          #
+          # @param [String] new_query
+          #   The new HTTP Query String for the request.
+          #
+          # @return [String]
+          #   The new HTTP Query String of the request.
+          #
+          # @api public
+          #
+          def query_string=(new_query)
+            @env['QUERY_STRING'] = new_query
+          end
+
+          #
+          # Toggles whether the request is a XML HTTP Request.
+          #
+          # @param [Boolean] xhr
+          #   Specifies whether the request is an XML HTTP Request.
+          #
+          # @return [Boolean]
+          #   Specifies whether the request is an XML HTTP Request.
+          #
+          # @api public
+          #
+          def xhr=(xhr)
+            if xhr then @env['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
+            else        @env.delete('HTTP_X_REQUESTED_WITH')
+            end
+
+            return xhr
+          end
+
+          #
+          # Changes the HTTP Content-Type header of the request.
+          #
+          # @param [String] new_content_type
+          #   The new HTTP Content-Type for the request.
+          #
+          # @return [String]
+          #   The new HTTP Content-Type of the request.
+          #
+          # @api public
+          #
+          def content_type=(new_content_type)
+            @env['CONTENT_TYPE'] = new_content_type
+          end
+
+          #
+          # Changes the HTTP Accept-Encoding header of the request.
+          #
+          # @param [String] new_encoding
+          #   The new HTTP Accept-Encoding for the request.
+          #
+          # @return [String]
+          #   The new HTTP Accept-Encoding of the request.
+          #
+          # @api public
+          #
+          def accept_encoding=(new_encoding)
+            @env['HTTP_ACCEPT_ENCODING'] = new_encoding
+          end
+
+          #
+          # Sets the HTTP User-Agent header of the request.
+          #
+          # @param [String] new_user_agent
+          #   The new User-Agent header to use.
+          #
+          # @return [String]
+          #   The new User-Agent header.
+          #
+          # @api public
+          #
+          def user_agent=(new_user_agent)
+            @env['HTTP_USER_AGENT'] = new_user_agent
+          end
+
+          #
+          # Changes the HTTP `Referer` header of the request.
+          #
+          # @param [String] new_referer
+          #   The new HTTP `Referer` header for the request.
+          #
+          # @return [String]
+          #   The new HTTP `Referer` header of the request.
+          #
+          # @api public
+          #
+          def referer=(new_referer)
+            @env['HTTP_REFERER'] = new_referer
+          end
+
+          alias referrer= referer=
+
+          #
+          # Changes the body of the request.
+          #
+          # @param [String] new_body
+          #   The new body for the request.
+          #
+          # @return [String]
+          #   The new body of the request.
+          #
+          # @api public
+          #
+          def body=(new_body)
+            @env['rack.input'] = new_body
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ronin/web/server/reverse_proxy/response.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+#
+# ronin-web-server - A custom Ruby web server based on Sinatra.
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-web-server is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-web-server is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-web-server.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/web/server/response'
+
+module Ronin
+  module Web
+    module Server
+      class ReverseProxy
+        #
+        # Class that represents a reverse proxied response.
+        #
+        class Response < Server::Response
+        end
+      end
+    end
+  end
+end

data/lib/ronin/web/server/reverse_proxy.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+#
+# ronin-web-server - A custom Ruby web server based on Sinatra.
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-web-server is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-web-server is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-web-server.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/web/server/reverse_proxy/request'
+require 'ronin/web/server/reverse_proxy/response'
+require 'ronin/support/network/http'
+
+require 'rack'
+
+module Ronin
+  module Web
+    module Server
+      #
+      # Reverse proxies Rack requests to other HTTP web servers.
+      #
+      # ## Examples
+      #
+      # ### Standalone Server
+      #
+      #     reverse_proxy = Ronin::Web::Server::ReverseProxy.new do |proxy|
+      #       proxy.on_request do |request|
+      #         # ...
+      #       end
+      #    
+      #       proxy.on_response do |response|
+      #         # ...
+      #       end
+      #     end
+      #     reverse_proxy.run!(host: '0.0.0.0', port: 8080)
+      #
+      # ### App
+      #
+      #     class App < Ronin::Web::Server::Base
+      #     
+      #       mount '/signin', Ronin::Web::Server::ReverseProxy.new
+      #     
+      #     end
+      #
+      # @api public
+      #
+      class ReverseProxy
+
+        #
+        # Creates a new reverse proxy application.
+        #
+        # @yield [reverse_proxy]
+        #   If a block is given, it will be passed the new proxy.
+        #
+        # @yieldparam [ReverseProxy] proxy
+        #   The new proxy object.
+        #
+        def initialize
+          @connections = {}
+
+          yield self if block_given?
+        end
+
+        #
+        # Registers a callback to run on each request.
+        #
+        # @yield [request]
+        #   The given block will be passed each received request before it has
+        #   been reverse proxied.
+        #
+        def on_request(&block)
+          @on_request_callback = block
+        end
+
+        #
+        # Registers a callback to run on each response.
+        #
+        # @yield [response]
+        #   The given block will be passed each response before it has been
+        #   returned.
+        #
+        # @yield [request, response]
+        #   If the block accepts two arguments then both the request and the
+        #   response objects will be yielded.
+        #
+        # @yieldparam [ReverseProxy::Response] response
+        #   A response object.
+        #
+        # @yieldparam [ReverseProxy::Request] request
+        #   A request object.
+        #
+        def on_response(&block)
+          @on_response_callback = block
+        end
+
+        #
+        # Reverse proxies every request using the `Host` header.
+        #
+        # @param [Hash{String => Object}] env
+        #   The rack request env Hash.
+        #
+        # @return [ReverseProxy::Response]
+        #   The rack response.
+        #
+        def call(env)
+          request = Request.new(env)
+          @on_request_callback.call(request) if @on_request_callback
+
+          response = reverse_proxy(request)
+
+          if @on_response_callback
+            if @on_response_callback.arity == 1
+              @on_response_callback.call(response)
+            else
+              @on_response_callback.call(request,response)
+            end
+          end
+
+          return response
+        end
+
+        #
+        # Creates a new connection or fetches an existing connection.
+        #
+        # @param [String] host
+        #   The host to connect to.
+        #
+        # @param [Integer] port
+        #   The port to connect to.
+        #
+        # @param [Boolean] ssl
+        #   Indicates whether to use SSL.
+        #
+        # @return [Ronin::Support::Network::HTTP]
+        #   The HTTP connection.
+        #
+        # @api private
+        #
+        def connection_for(host,port, ssl: nil)
+          key = [host,port,ssl]
+
+          @connections.fetch(key) do
+            @connections[key] = Support::Network::HTTP.new(host,port, ssl: ssl)
+          end
+        end
+
+        # Blacklisted HTTP response Headers.
+        IGNORED_HEADERS = Set[
+          'Transfer-Encoding'
+        ]
+
+        #
+        # Reverse proxies the given request.
+        #
+        # @param [ReverseProxy::Request] request
+        #   The incoming request to reverse proxy.
+        #
+        # @return [ReverseProxy::Response]
+        #   The reverse proxied response.
+        #
+        def reverse_proxy(request)
+          host    = request.host
+          port    = request.port
+          ssl     = request.scheme == 'https'
+          method  = request.request_method.downcase.to_sym
+          path    = request.path
+          query   = request.query_string
+          headers = request.headers
+          body    = request.body.read
+
+          http = connection_for(host,port, ssl: ssl)
+          http_response = http.request(method,path, query:   query,
+                                                    headers: headers,
+                                                    body:    body)
+          response_headers = {}
+
+          http_response.each_capitalized do |name,value|
+            unless IGNORED_HEADERS.include?(name)
+              response_headers[name] = value
+            end
+          end
+
+          response_body   = http_response.body || ''
+          response_status = http_response.code.to_i
+
+          return Response.new(response_body,response_status,response_headers)
+        end
+
+        #
+        # @group Standalone Server Methods
+        #
+
+        # Default host the Proxy will bind to
+        DEFAULT_HOST = '0.0.0.0'
+
+        # Default port the Proxy will listen on
+        DEFAULT_PORT = 8080
+
+        # Default server the Proxy will run on
+        DEFAULT_SERVER = 'webrick'
+
+        #
+        # Runs the reverse proxy as a standalone HTTP server.
+        #
+        # @param [String] host
+        #   The host to bind to.
+        #
+        # @param [Integer] port
+        #   The port to listen on.
+        #
+        # @param [String] server
+        #   The Rack server to run the reverse proxy under.
+        #
+        # @param [Hash{Symbol => Object}] rack_options
+        #   Additional options to pass to [Rack::Server.new](https://rubydoc.info/gems/rack/Rack/Server#initialize-instance_method).
+        #
+        def run!(host: DEFAULT_HOST, port: DEFAULT_PORT, server: DEFAULT_SERVER,
+                 **rack_options)
+          server = Rack::Server.new(
+            app:    self,
+            server: server,
+            Host:   host,
+            Port:   port,
+            **rack_options
+          )
+
+          server.start do |handler|
+            trap(:INT)  { quit!(server,handler) }
+            trap(:TERM) { quit!(server,handler) }
+          end
+
+          return self
+        end
+
+        #
+        # Stops the reverse proxy server.
+        #
+        # @param [Rack::Server] server
+        #   The Rack Handler server.
+        #
+        # @param [#stop!, #stop] handler
+        #   The Rack Handler.
+        #
+        # @api private
+        #
+        def quit!(server,handler)
+          # Use thins' hard #stop! if available, otherwise just #stop
+          handler.respond_to?(:stop!) ? handler.stop! : handler.stop
+        end
+
+      end
+    end
+  end
+end