cybrid_api_id_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/proxy/socks4.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "resolv"
+require "ipaddr"
+
+module HTTPX
+  class Socks4Error < ProxyError; end
+
+  module Plugins
+    module Proxy
+      module Socks4
+        VERSION = 4
+        CONNECT = 1
+        GRANTED = 0x5A
+        PROTOCOLS = %w[socks4 socks4a].freeze
+
+        Error = Socks4Error
+
+        class << self
+          def extra_options(options)
+            options.merge(supported_proxy_protocols: options.supported_proxy_protocols + PROTOCOLS)
+          end
+        end
+
+        module ConnectionMethods
+          def interests
+            if @state == :connecting
+              return @write_buffer.empty? ? :r : :w
+            end
+
+            super
+          end
+
+          private
+
+          def handle_transition(nextstate)
+            return super unless @options.proxy && PROTOCOLS.include?(@options.proxy.uri.scheme)
+
+            case nextstate
+            when :connecting
+              return unless @state == :idle
+
+              @io.connect
+              return unless @io.connected?
+
+              req = @pending.first
+              return unless req
+
+              request_uri = req.uri
+              @write_buffer << Packet.connect(@options.proxy, request_uri)
+              __socks4_proxy_connect
+            when :connected
+              return unless @state == :connecting
+
+              @parser = nil
+            end
+            log(level: 1) { "SOCKS4: #{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
+            super
+          end
+
+          def __socks4_proxy_connect
+            @parser = SocksParser.new(@write_buffer, @options)
+            @parser.once(:packet, &method(:__socks4_on_packet))
+          end
+
+          def __socks4_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(:connected)
+              throw(:called)
+            else
+              on_socks4_error("socks error: #{status}")
+            end
+          end
+
+          def on_socks4_error(message)
+            ex = Error.new(message)
+            ex.set_backtrace(caller)
+            on_error(ex)
+            throw(:called)
+          end
+        end
+
+        class SocksParser
+          include HTTPX::Callbacks
+
+          def initialize(buffer, options)
+            @buffer = buffer
+            @options = 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")
+
+            case parameters.uri.scheme
+            when "socks4"
+              socks_host = uri.host
+              begin
+                ip = IPAddr.new(socks_host)
+                packet << ip.hton
+              rescue IPAddr::InvalidAddressError
+                socks_host = Resolv.getaddress(socks_host)
+                retry
+              end
+              packet << [parameters.username].pack("Z*")
+            when "socks4a"
+              packet << "\x0\x0\x0\x1" << [parameters.username].pack("Z*") << uri.host << "\x0"
+            end
+            packet
+          end
+        end
+      end
+    end
+    register_plugin :"proxy/socks4", Proxy::Socks4
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/proxy/socks5.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module HTTPX
+  class Socks5Error < ProxyError; end
+
+  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 = Socks5Error
+
+        class << self
+          def load_dependencies(*)
+            require_relative "../auth/socks5"
+          end
+
+          def extra_options(options)
+            options.merge(supported_proxy_protocols: options.supported_proxy_protocols + %w[socks5])
+          end
+        end
+
+        module ConnectionMethods
+          def call
+            super
+
+            return unless @options.proxy && @options.proxy.uri.scheme == "socks5"
+
+            case @state
+            when :connecting,
+                 :negotiating,
+                 :authenticating
+              consume
+            end
+          end
+
+          def connecting?
+            super || @state == :authenticating || @state == :negotiating
+          end
+
+          def interests
+            if @state == :connecting || @state == :authenticating || @state == :negotiating
+              return @write_buffer.empty? ? :r : :w
+            end
+
+            super
+          end
+
+          private
+
+          def handle_transition(nextstate)
+            return super unless @options.proxy && @options.proxy.uri.scheme == "socks5"
+
+            case nextstate
+            when :connecting
+              return unless @state == :idle
+
+              @io.connect
+              return unless @io.connected?
+
+              @write_buffer << Packet.negotiate(@options.proxy)
+              __socks5_proxy_connect
+            when :authenticating
+              return unless @state == :connecting
+
+              @write_buffer << Packet.authenticate(@options.proxy)
+            when :negotiating
+              return unless @state == :connecting || @state == :authenticating
+
+              req = @pending.first
+              request_uri = req.uri
+              @write_buffer << Packet.connect(request_uri)
+            when :connected
+              return unless @state == :negotiating
+
+              @parser = nil
+            end
+            log(level: 1) { "SOCKS5: #{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
+            super
+          end
+
+          def __socks5_proxy_connect
+            @parser = SocksParser.new(@write_buffer, @options)
+            @parser.on(:packet, &method(:__socks5_on_packet))
+            transition(:negotiating)
+          end
+
+          def __socks5_on_packet(packet)
+            case @state
+            when :connecting
+              version, method = packet.unpack("CC")
+              __socks5_check_version(version)
+              case method
+              when PASSWD
+                transition(:authenticating)
+                nil
+              when NONE
+                __on_socks5_error("no supported authorization methods")
+              else
+                transition(:negotiating)
+              end
+            when :authenticating
+              _, status = packet.unpack("CC")
+              return transition(:negotiating) if status == SUCCESS
+
+              __on_socks5_error("socks authentication error: #{status}")
+            when :negotiating
+              version, reply, = packet.unpack("CC")
+              __socks5_check_version(version)
+              __on_socks5_error("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(:connected)
+              throw(:called)
+            end
+          end
+
+          def __socks5_check_version(version)
+            __on_socks5_error("invalid SOCKS version (#{version})") if version != 5
+          end
+
+          def __on_socks5_error(message)
+            ex = Error.new(message)
+            ex.set_backtrace(caller)
+            on_error(ex)
+            throw(:called)
+          end
+        end
+
+        class SocksParser
+          include HTTPX::Callbacks
+
+          def initialize(buffer, options)
+            @buffer = buffer
+            @options = 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.can_authenticate?
+            methods.unshift(methods.size)
+            methods.unshift(VERSION)
+            methods.pack("C*")
+          end
+
+          def authenticate(parameters)
+            parameters.authenticate
+          end
+
+          def connect(uri)
+            packet = [VERSION, CONNECT, 0].pack("C*")
+            begin
+              ip = IPAddr.new(uri.host)
+
+              ipcode = ip.ipv6? ? IPV6 : IPV4
+
+              packet << [ipcode].pack("C") << ip.hton
+            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

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/proxy/ssh.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "httpx/plugins/proxy"
+
+module HTTPX
+  module Plugins
+    module Proxy
+      module SSH
+        class << self
+          def load_dependencies(*)
+            require "net/ssh/gateway"
+          end
+        end
+
+        module OptionsMethods
+          private
+
+          def option_proxy(value)
+            Hash[value]
+          end
+        end
+
+        module InstanceMethods
+          def request(*args, **options)
+            raise ArgumentError, "must perform at least one request" if args.empty?
+
+            requests = args.first.is_a?(Request) ? args : build_requests(*args, options)
+
+            request = requests.first or return super
+
+            request_options = request.options
+
+            return super unless request_options.proxy
+
+            ssh_options = request_options.proxy
+            ssh_uris = ssh_options.delete(:uri)
+            ssh_uri = URI.parse(ssh_uris.shift)
+
+            return super unless ssh_uri.scheme == "ssh"
+
+            ssh_username = ssh_options.delete(:username)
+            ssh_options[:port] ||= ssh_uri.port || 22
+            if request_options.debug
+              ssh_options[:verbose] = request_options.debug_level == 2 ? :debug : :info
+            end
+
+            request_uri = URI(requests.first.uri)
+            @_gateway = Net::SSH::Gateway.new(ssh_uri.host, ssh_username, ssh_options)
+            begin
+              @_gateway.open(request_uri.host, request_uri.port) do |local_port|
+                io = build_gateway_socket(local_port, request_uri, request_options)
+                super(*args, **options.merge(io: io))
+              end
+            ensure
+              @_gateway.shutdown!
+            end
+          end
+
+          private
+
+          def build_gateway_socket(port, request_uri, options)
+            case request_uri.scheme
+            when "https"
+              ctx = OpenSSL::SSL::SSLContext.new
+              ctx_options = SSL::TLS_OPTIONS.merge(options.ssl)
+              ctx.set_params(ctx_options) unless ctx_options.empty?
+              sock = TCPSocket.open("localhost", port)
+              io = OpenSSL::SSL::SSLSocket.new(sock, ctx)
+              io.hostname = request_uri.host
+              io.sync_close = true
+              io.connect
+              io.post_connection_check(request_uri.host) if ctx.verify_mode != OpenSSL::SSL::VERIFY_NONE
+              io
+            when "http"
+              TCPSocket.open("localhost", port)
+            else
+              raise TypeError, "unexpected scheme: #{request_uri.scheme}"
+            end
+          end
+        end
+
+        module ConnectionMethods
+          # should not coalesce connections here, as the IP is the IP of the proxy
+          def coalescable?(*)
+            return super unless @options.proxy
+
+            false
+          end
+        end
+      end
+    end
+    register_plugin :"proxy/ssh", Proxy::SSH
+  end
+end