httpx 0.0.1

data/lib/httpx/plugins/proxy.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTPX
+  module Plugins
+    module Proxy
+      Error = Class.new(Error)
+      class Parameters
+        extend Registry
+
+        attr_reader :uri, :username, :password
+
+        def initialize(uri:, username: nil, password: nil)
+          @uri = uri.is_a?(URI::Generic) ? uri : URI(uri)
+          @username = username || @uri.user
+          @password = password || @uri.password
+        end
+
+        def authenticated?
+          @username && @password
+        end
+
+        def token_authentication
+          Base64.strict_encode64("#{user}:#{password}")
+        end
+      end
+
+      module InstanceMethods
+        def with_proxy(*args)
+          branch(default_options.with_proxy(*args))
+        end
+
+        private
+
+        def proxy_params(uri)
+          return @options.proxy if @options.proxy
+          uri = URI(uri).find_proxy
+          return unless uri
+          { uri: uri }
+        end
+
+        def find_channel(request, **options)
+          uri = URI(request.uri)
+          proxy = proxy_params(uri)
+          return super unless proxy
+          @connection.find_channel(proxy) || begin
+            channel = build_proxy_channel(proxy, **options)
+            set_channel_callbacks(channel)
+            channel
+          end
+        end
+
+        def build_proxy_channel(proxy, **options)
+          parameters = Parameters.new(**proxy)
+          uri = parameters.uri
+          log { "proxy: #{uri}" }
+          io = TCP.new(uri.host, uri.port, @options)
+          proxy_type = Parameters.registry(parameters.uri.scheme)
+          channel = proxy_type.new(io, parameters, @options.merge(options), &method(:on_response))
+          @connection.__send__(:register_channel, channel)
+          channel
+        end
+      end
+
+      module OptionsMethods
+        def self.included(klass)
+          super
+          klass.def_option(:proxy) do |pr|
+            Hash[pr]
+          end
+        end
+      end
+
+      def self.configure(klass, *)
+        klass.plugin(:"proxy/http")
+        klass.plugin(:"proxy/socks4")
+        klass.plugin(:"proxy/socks5")
+      end
+    end
+    register_plugin :proxy, Proxy
+  end
+
+  class ProxyChannel < Channel
+    def initialize(io, parameters, options, &blk)
+      super(io, options, &blk)
+      @parameters = parameters
+    end
+
+    def match?(*)
+      true
+    end
+
+    def to_io
+      transition(:connecting) if @state == :idle
+      @io.to_io
+    end
+  end
+
+  class ProxySSL < SSL
+    def initialize(tcp, request_uri, options)
+      @io = tcp.to_io
+      super(tcp.ip, tcp.port, options)
+      @hostname = request_uri.host
+      @state = :connected
+    end
+  end
+end

data/lib/httpx/plugins/proxy/http.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module HTTPX
+  module Plugins
+    module Proxy
+      module HTTP
+        class HTTPProxyChannel < ProxyChannel
+          private
+
+          def proxy_connect
+            req, _ = @pending.first
+            # if the first request after CONNECT is to an https address, it is assumed that
+            # all requests in the queue are not only ALL HTTPS, but they also share the certificate,
+            # and therefore, will share the connection.
+            #
+            if req.uri.scheme == "https"
+              connect_request = ConnectRequest.new(req.uri)
+              if @parameters.authenticated?
+                connect_request.headers["proxy-authentication"] = "Basic #{@parameters.token_authentication}"
+              end
+              parser.send(connect_request)
+            else
+              transition(:open)
+            end
+          end
+
+          def transition(nextstate)
+            case nextstate
+            when :connecting
+              return unless @state == :idle
+              @io.connect
+              return if @io.closed?
+              @parser = ConnectProxyParser.new(@write_buffer, @options.merge(max_concurrent_requests: 1))
+              @parser.once(:response, &method(:on_connect))
+              @parser.on(:complete) { throw(:close, self) }
+              proxy_connect
+              return if @state == :open
+            when :open
+              case @state
+              when :connecting
+                @parser.close
+                @parser = nil
+              when :idle
+                @parser = ProxyParser.new(@write_buffer, @options)
+                @parser.inherit_callbacks(self)
+                @parser.on(:complete) { throw(:close, self) }
+              end
+            end
+            super
+          end
+
+          def on_connect(_request, response)
+            if response.status == 200
+              req, _ = @pending.first
+              request_uri = req.uri
+              @io = ProxySSL.new(@io, request_uri, @options)
+              transition(:open)
+              throw(:called)
+            else
+              pending = @pending.map(&:first) + @parser.pending
+              while (req = pending.shift)
+                emit(:response, req, response)
+              end
+            end
+          end
+        end
+
+        class ProxyParser < Channel::HTTP1
+          def headline_uri(request)
+            request.uri.to_s
+          end
+
+          def set_request_headers(request)
+            super
+            request.headers["proxy-connection"] = request.headers["connection"]
+            request.headers.delete("connection")
+          end
+        end
+
+        class ConnectProxyParser < ProxyParser
+          attr_reader :pending
+
+          def headline_uri(request)
+            return super unless request.verb == :connect
+            uri = request.uri
+            tunnel = "#{uri.hostname}:#{uri.port}"
+            log { "establishing HTTP proxy tunnel to #{tunnel}" }
+            tunnel
+          end
+
+          def empty?
+            @requests.reject { |r| r.verb == :connect }.empty? ||
+              @requests.all? { |request| !request.response.nil? }
+          end
+        end
+
+        class ConnectRequest < Request
+          def initialize(uri, options = {})
+            super(:connect, uri, options)
+            @headers.delete("accept")
+          end
+
+          def path
+            "#{@uri.hostname}:#{@uri.port}"
+          end
+        end
+
+        Parameters.register("http", HTTPProxyChannel)
+      end
+    end
+    register_plugin :"proxy/http", Proxy::HTTP
+  end
+end

data/lib/httpx/plugins/proxy/socks4.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "resolv"
+require "ipaddr"
+
+module HTTPX
+  module Plugins
+    module Proxy
+      module Socks4
+        VERSION = 4
+        CONNECT = 1
+        GRANTED = 90
+
+        Error = Class.new(Error)
+
+        class Socks4ProxyChannel < ProxyChannel
+          private
+
+          def proxy_connect
+            @parser = SocksParser.new(@write_buffer, @options)
+            @parser.once(:packet, &method(:on_packet))
+          end
+
+          def on_packet(packet)
+            _version, status, _port, _ip = packet.unpack("CCnN")
+            if status == GRANTED
+              req, _ = @pending.first
+              request_uri = req.uri
+              @io = ProxySSL.new(@io, request_uri, @options) if request_uri.scheme == "https"
+              transition(:open)
+              throw(:called)
+            else
+              response = ErrorResponse.new("socks error: #{status}", 0)
+              until @pending.empty?
+                req, _ = @pending.shift
+                emit(:response, req, response)
+              end
+            end
+          end
+
+          def transition(nextstate)
+            case nextstate
+            when :connecting
+              return unless @state == :idle
+              @io.connect
+              return if @io.closed?
+              req, _ = @pending.first
+              return unless req
+              request_uri = req.uri
+              @write_buffer << Packet.connect(@parameters, request_uri)
+              proxy_connect
+            when :open
+              return unless @state == :connecting
+              @parser = nil
+            end
+            log(1, "SOCKS4: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" }
+            super
+          end
+        end
+        Parameters.register("socks4", Socks4ProxyChannel)
+        Parameters.register("socks4a", Socks4ProxyChannel)
+
+        class SocksParser
+          include Callbacks
+
+          def initialize(buffer, options)
+            @buffer = buffer
+            @options = Options.new(options)
+          end
+
+          def close; end
+
+          def consume(*); end
+
+          def empty?
+            true
+          end
+
+          def <<(packet)
+            emit(:packet, packet)
+          end
+        end
+
+        module Packet
+          module_function
+
+          def connect(parameters, uri)
+            packet = [VERSION, CONNECT, uri.port].pack("CCn")
+            begin
+              ip = IPAddr.new(uri.host)
+              raise Error, "Socks4 connection to #{ip} not supported" unless ip.ipv4?
+              packet << [ip.to_i].pack("N")
+            rescue IPAddr::InvalidAddressError
+              if parameters.uri.scheme == "socks4"
+                # resolv defaults to IPv4, and socks4 doesn't support IPv6 otherwise
+                ip = IPAddr.new(Resolv.getaddress(uri.host))
+                packet << [ip.to_i].pack("N")
+              else
+                packet << "\x0\x0\x0\x1" << "\x7\x0" << uri.host
+              end
+            end
+            packet << [parameters.username].pack("Z*")
+            packet
+          end
+        end
+      end
+    end
+    register_plugin :"proxy/socks4", Proxy::Socks4
+  end
+end

data/lib/httpx/plugins/proxy/socks5.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Proxy
+      module Socks5
+        VERSION = 5
+        NOAUTH = 0
+        PASSWD = 2
+        NONE   = 0xff
+        CONNECT = 1
+        IPV4 = 1
+        DOMAIN = 3
+        IPV6 = 4
+        SUCCESS = 0
+
+        Error = Class.new(Error)
+
+        class Socks5ProxyChannel < ProxyChannel
+          private
+
+          def proxy_connect
+            @parser = SocksParser.new(@write_buffer, @options)
+            @parser.on(:packet, &method(:on_packet))
+            transition(:negotiating)
+          end
+
+          def on_packet(packet)
+            case @state
+            when :connecting
+              version, method = packet.unpack("CC")
+              check_version(version)
+              case method
+              when PASSWD
+                transition(:authenticating)
+                return
+              when NONE
+                on_error_response("no supported authorization methods")
+              else
+                transition(:negotiating)
+              end
+            when :authenticating
+              version, status = packet.unpack("CC")
+              check_version(version)
+              return transition(:negotiating) if status == SUCCESS
+              on_error_response("socks authentication error: #{status}")
+            when :negotiating
+              version, reply, = packet.unpack("CC")
+              check_version(version)
+              return on_error_response("socks5 negotiation error: #{reply}") unless reply == SUCCESS
+              req, _ = @pending.first
+              request_uri = req.uri
+              @io = ProxySSL.new(@io, request_uri, @options) if request_uri.scheme == "https"
+              transition(:open)
+              throw(:called)
+            end
+          end
+
+          def transition(nextstate)
+            case nextstate
+            when :connecting
+              return unless @state == :idle
+              @io.connect
+              return if @io.closed?
+              @write_buffer << Packet.negotiate(@parameters)
+              proxy_connect
+            when :authenticating
+              return unless @state == :connecting
+              @write_buffer << Packet.authenticate(@parameters)
+            when :negotiating
+              return unless @state == :connecting || @state == :authenticating
+              req, _ = @pending.first
+              request_uri = req.uri
+              @write_buffer << Packet.connect(request_uri)
+            when :open
+              return unless @state == :negotiating
+              @parser = nil
+            end
+            log(1, "SOCKS5: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" }
+            super
+          end
+
+          def check_version(version)
+            raise Error, "invalid SOCKS version (#{version})" if version != 5
+          end
+
+          def on_error_response(error)
+            response = ErrorResponse.new(error, 0)
+            until @pending.empty?
+              req, _ = @pending.shift
+              emit(:response, req, response)
+            end
+          end
+        end
+        Parameters.register("socks5", Socks5ProxyChannel)
+
+        class SocksParser
+          include Callbacks
+
+          def initialize(buffer, options)
+            @buffer = buffer
+            @options = Options.new(options)
+          end
+
+          def close; end
+
+          def consume(*); end
+
+          def empty?
+            true
+          end
+
+          def <<(packet)
+            emit(:packet, packet)
+          end
+        end
+
+        module Packet
+          module_function
+
+          def negotiate(parameters)
+            methods = [NOAUTH]
+            methods << PASSWD if parameters.authenticated?
+            methods.unshift(methods.size)
+            methods.unshift(VERSION)
+            methods.pack("C*")
+          end
+
+          def authenticate(parameters)
+            user = parameters.username
+            pass = parameters.password
+            [0x01, user.bytesize, user, pass.bytesize, password].pack("CCA*CA*")
+          end
+
+          def connect(uri)
+            packet = [VERSION, CONNECT, 0].pack("C*")
+            begin
+              ip = IPAddr.new(uri.host)
+              raise Error, "Socks4 connection to #{ip} not supported" unless ip.ipv4?
+              packet << [IPV4, ip.to_i].pack("CN")
+            rescue IPAddr::InvalidAddressError
+              packet << [DOMAIN, uri.host.bytesize, uri.host].pack("CCA*")
+            end
+            packet << [uri.port].pack("n")
+            packet
+          end
+        end
+      end
+    end
+    register_plugin :"proxy/socks5", Proxy::Socks5
+  end
+end