@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/rubygems/gemcutter_utilities/webauthn_listener/response.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-##
-# The WebauthnListener Response class is used by the WebauthnListener to create
-# responses to be sent to the Gem host. It creates a Gem::Net::HTTPResponse instance
-# when initialized and can be converted to the appropriate format to be sent by a socket using `to_s`.
-# Gem::Net::HTTPResponse instances cannot be directly sent over a socket.
-#
-# Types of response classes:
-#   - OkResponse
-#   - NoContentResponse
-#   - BadRequestResponse
-#   - NotFoundResponse
-#   - MethodNotAllowedResponse
-#
-# Example usage:
-#
-#   server = TCPServer.new(0)
-#   socket = server.accept
-#
-#   response = OkResponse.for("https://rubygems.example")
-#   socket.print response.to_s
-#   socket.close
-#
-
-module Gem::GemcutterUtilities
-  class WebauthnListener
-    class Response
-      attr_reader :http_response
-
-      def self.for(host)
-        new(host)
-      end
-
-      def initialize(host)
-        @host = host
-
-        build_http_response
-      end
-
-      def to_s
-        status_line = "HTTP/#{@http_response.http_version} #{@http_response.code} #{@http_response.message}\r\n"
-        headers = @http_response.to_hash.map {|header, value| "#{header}: #{value.join(", ")}\r\n" }.join + "\r\n"
-        body = @http_response.body ? "#{@http_response.body}\n" : ""
-
-        status_line + headers + body
-      end
-
-      private
-
-      # Must be implemented in subclasses
-      def code
-        raise NotImplementedError
-      end
-
-      def reason_phrase
-        raise NotImplementedError
-      end
-
-      def body; end
-
-      def build_http_response
-        response_class = Gem::Net::HTTPResponse::CODE_TO_OBJ[code.to_s]
-        @http_response = response_class.new("1.1", code, reason_phrase)
-        @http_response.instance_variable_set(:@read, true)
-
-        add_connection_header
-        add_access_control_headers
-        add_body
-      end
-
-      def add_connection_header
-        @http_response["connection"] = "close"
-      end
-
-      def add_access_control_headers
-        @http_response["access-control-allow-origin"] = @host
-        @http_response["access-control-allow-methods"] = "POST"
-        @http_response["access-control-allow-headers"] = %w[Content-Type Authorization x-csrf-token]
-      end
-
-      def add_body
-        return unless body
-        @http_response["content-type"] = "text/plain; charset=utf-8"
-        @http_response["content-length"] = body.bytesize
-        @http_response.instance_variable_set(:@body, body)
-      end
-    end
-
-    class OkResponse < Response
-      private
-
-      def code
-        200
-      end
-
-      def reason_phrase
-        "OK"
-      end
-
-      def body
-        "success"
-      end
-    end
-
-    class NoContentResponse < Response
-      private
-
-      def code
-        204
-      end
-
-      def reason_phrase
-        "No Content"
-      end
-    end
-
-    class BadRequestResponse < Response
-      private
-
-      def code
-        400
-      end
-
-      def reason_phrase
-        "Bad Request"
-      end
-
-      def body
-        "missing code parameter"
-      end
-    end
-
-    class NotFoundResponse < Response
-      private
-
-      def code
-        404
-      end
-
-      def reason_phrase
-        "Not Found"
-      end
-    end
-
-    class MethodNotAllowedResponse < Response
-      private
-
-      def code
-        405
-      end
-
-      def reason_phrase
-        "Method Not Allowed"
-      end
-
-      def add_access_control_headers
-        super
-        @http_response["allow"] = %w[GET OPTIONS]
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/rubygems/gemcutter_utilities/webauthn_listener.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "webauthn_listener/response"
-
-##
-# The WebauthnListener class retrieves an OTP after a user successfully WebAuthns with the Gem host.
-# An instance opens a socket using the TCPServer instance given and listens for a request from the Gem host.
-# The request should be a GET request to the root path and contains the OTP code in the form
-# of a query parameter `code`. The listener will return the code which will be used as the OTP for
-# API requests.
-#
-# Types of responses sent by the listener after receiving a request:
-#   - 200 OK: OTP code was successfully retrieved
-#   - 204 No Content: If the request was an OPTIONS request
-#   - 400 Bad Request: If the request did not contain a query parameter `code`
-#   - 404 Not Found: The request was not to the root path
-#   - 405 Method Not Allowed: OTP code was not retrieved because the request was not a GET/OPTIONS request
-#
-# Example usage:
-#
-#   thread = Gem::WebauthnListener.listener_thread("https://rubygems.example", server)
-#   thread.join
-#   otp = thread[:otp]
-#   error = thread[:error]
-#
-
-module Gem::GemcutterUtilities
-  class WebauthnListener
-    attr_reader :host
-
-    def initialize(host)
-      @host = host
-    end
-
-    def self.listener_thread(host, server)
-      Thread.new do
-        thread = Thread.current
-        thread.abort_on_exception = true
-        thread.report_on_exception = false
-        thread[:otp] = new(host).wait_for_otp_code(server)
-      rescue Gem::WebauthnVerificationError => e
-        thread[:error] = e
-      ensure
-        server.close
-      end
-    end
-
-    def wait_for_otp_code(server)
-      loop do
-        socket = server.accept
-        request_line = socket.gets
-
-        method, req_uri, _protocol = request_line.split(" ")
-        req_uri = Gem::URI.parse(req_uri)
-
-        responder = SocketResponder.new(socket)
-
-        unless root_path?(req_uri)
-          responder.send(NotFoundResponse.for(host))
-          raise Gem::WebauthnVerificationError, "Page at #{req_uri.path} not found."
-        end
-
-        case method.upcase
-        when "OPTIONS"
-          responder.send(NoContentResponse.for(host))
-          next # will be GET
-        when "GET"
-          if otp = parse_otp_from_uri(req_uri)
-            responder.send(OkResponse.for(host))
-            return otp
-          end
-          responder.send(BadRequestResponse.for(host))
-          raise Gem::WebauthnVerificationError, "Did not receive OTP from #{host}."
-        else
-          responder.send(MethodNotAllowedResponse.for(host))
-          raise Gem::WebauthnVerificationError, "Invalid HTTP method #{method.upcase} received."
-        end
-      end
-    end
-
-    private
-
-    def root_path?(uri)
-      uri.path == "/"
-    end
-
-    def parse_otp_from_uri(uri)
-      require "cgi"
-
-      return if uri.query.nil?
-      CGI.parse(uri.query).dig("code", 0)
-    end
-
-    class SocketResponder
-      def initialize(socket)
-        @socket = socket
-      end
-
-      def send(response)
-        @socket.print response.to_s
-        @socket.close
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/rubygems/gemcutter_utilities/webauthn_poller.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-##
-# The WebauthnPoller class retrieves an OTP after a user successfully WebAuthns. An instance
-# polls the Gem host for the OTP code. The polling request (api/v1/webauthn_verification/<webauthn_token>/status.json)
-# is sent to the Gem host every 5 seconds and will timeout after 5 minutes. If the status field in the json response
-# is "success", the code field will contain the OTP code.
-#
-# Example usage:
-#
-#   thread = Gem::WebauthnPoller.poll_thread(
-#     {},
-#     "RubyGems.org",
-#     "https://rubygems.org/api/v1/webauthn_verification/odow34b93t6aPCdY",
-#     { email: "email@example.com", password: "password" }
-#   )
-#   thread.join
-#   otp = thread[:otp]
-#   error = thread[:error]
-#
-
-module Gem::GemcutterUtilities
-  class WebauthnPoller
-    include Gem::GemcutterUtilities
-    TIMEOUT_IN_SECONDS = 300
-
-    attr_reader :options, :host
-
-    def initialize(options, host)
-      @options = options
-      @host = host
-    end
-
-    def self.poll_thread(options, host, webauthn_url, credentials)
-      Thread.new do
-        thread = Thread.current
-        thread.abort_on_exception = true
-        thread.report_on_exception = false
-        thread[:otp] = new(options, host).poll_for_otp(webauthn_url, credentials)
-      rescue Gem::WebauthnVerificationError, Gem::Timeout::Error => e
-        thread[:error] = e
-      end
-    end
-
-    def poll_for_otp(webauthn_url, credentials)
-      Gem::Timeout.timeout(TIMEOUT_IN_SECONDS) do
-        loop do
-          response = webauthn_verification_poll_response(webauthn_url, credentials)
-          raise Gem::WebauthnVerificationError, response.message unless response.is_a?(Gem::Net::HTTPSuccess)
-
-          require "json"
-          parsed_response = JSON.parse(response.body)
-          case parsed_response["status"]
-          when "pending"
-            sleep 5
-          when "success"
-            return parsed_response["code"]
-          else
-            raise Gem::WebauthnVerificationError, parsed_response.fetch("message", "Invalid response from server")
-          end
-        end
-      end
-    end
-
-    private
-
-    def webauthn_verification_poll_response(webauthn_url, credentials)
-      webauthn_token = %r{(?<=\/)[^\/]+(?=$)}.match(webauthn_url)[0]
-      rubygems_api_request(:get, "api/v1/webauthn_verification/#{webauthn_token}/status.json") do |request|
-        if credentials.empty?
-          request.add_field "Authorization", api_key
-        elsif credentials[:identifier] && credentials[:password]
-          request.basic_auth credentials[:identifier], credentials[:password]
-        else
-          raise Gem::WebauthnVerificationError, "Provided missing credentials"
-        end
-      end
-    end
-  end
-end