sqrl-client 0.1.0

data/lib/sqrl/client/errors.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SQRL
+  module Client
+    # Base class of every error raised by the client gem.
+    class Error < SQRL::Error; end
+
+    # No SQRL login URL could be found for the target.
+    class DiscoveryError < Error; end
+
+    # The server posed an +ask=+ question and no +ask_handler+ was configured to answer it.
+    class AskRequired < Error
+      # @return [SQRL::Ask]
+      attr_reader :ask
+
+      def initialize(ask)
+        @ask = ask
+        super("the server asks: #{ask.message.inspect} (buttons: #{ask.buttons.map(&:label).inspect}); " \
+              "configure an ask_handler to answer it")
+      end
+    end
+
+    # The transaction ended without the requested outcome. +tif+ is the last TIF received,
+    # +reason+ a Symbol such as +:disabled+, +:superseded+, +:unknown_site+, +:ip_mismatch+,
+    # +:command_failed+ or +:transient+.
+    class LoginFailed < Error
+      attr_reader :tif, :reason, :state, :result
+
+      def initialize(message, reason:, tif: nil, state: nil, result: nil)
+        @reason = reason
+        @tif = tif
+        @state = state
+        @result = result
+        super(message)
+      end
+    end
+
+    # The HTTP layer failed (connection refused, TLS error, timeout, non-2xx SQRL endpoint).
+    class TransportError < Error
+      attr_reader :url, :status
+
+      def initialize(message, url: nil, status: nil)
+        @url = url
+        @status = status
+        super(message)
+      end
+    end
+
+    # An operation needs the Identity Unlock Key (rescue code) and it is not available.
+    class IdentityLocked < Error; end
+  end
+end

data/lib/sqrl/client/identity.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module SQRL
+  module Client
+    # An identity as a bot uses it: an unlocked {SQRL::UnlockedIdentity} plus, when known,
+    # the Identity Unlock Key needed for +enable+, +remove+ and re-keying, optionally backed
+    # by an S4 identity file.
+    #
+    #   SQRL::Client::Identity.load("bot.sqrl", password: "…")      # S4 file (binary or SQRLDATA text)
+    #   SQRL::Client::Identity.from_textual(text, rescue_code: "…")  # rescue-only textual import
+    #   SQRL::Client::Identity.create(password: "…")                 # brand new, returns the rescue code
+    #   SQRL::Client::Identity.ephemeral                              # random IUK, no EnScrypt (tests)
+    #   SQRL::Client::Identity.ephemeral("seed")                      # deterministic from a seed
+    #   SQRL::Client::Identity.from_env                               # SQRL_IDENTITY_FILE / SQRL_IUK_HEX …
+    class Identity
+      # @return [SQRL::UnlockedIdentity]
+      attr_reader :unlocked
+      # @return [SQRL::S4Identity, nil] the identity file, when there is one
+      attr_reader :s4
+      # @return [String, nil] where the identity file lives
+      attr_reader :path
+      # @return [String, nil] the rescue code, only right after {.create} or {#rekey!}
+      attr_reader :rescue_code
+
+      # A fast clock for identity creation in tests: every call advances one second so a
+      # one-second EnScrypt finishes after one iteration.
+      def self.fast_clock
+        t = 0
+        -> { t += 1000 }
+      end
+
+      # Load an S4 identity file (binary +sqrldata+ or +SQRLDATA+ text) and unlock it.
+      #
+      # @param path [String]
+      # @param password [String]
+      # @param rescue_code [String, nil] also recover the IUK (slow; needed for enable/remove)
+      def self.load(path, password:, rescue_code: nil)
+        s4 = S4Identity.parse(File.binread(path))
+        from_s4(s4, password: password, rescue_code: rescue_code, path: path)
+      end
+
+      # Unlock a parsed {SQRL::S4Identity}.
+      def self.from_s4(s4, password:, rescue_code: nil, path: nil)
+        unless s4.password_block?
+          raise IdentityLocked,
+                "identity file has no password block; import it with the rescue code"
+        end
+
+        identity = new(s4.unlock(password.to_s), s4: s4, path: path)
+        identity.unlock_iuk!(rescue_code) if rescue_code
+        identity
+      end
+
+      # Import a rescue-only textual identity (the base56 export) with its rescue code. The
+      # IUK is recovered, so the identity can enable/remove right away. Pass +password:+ to
+      # also build a password block (returned via {#s4}).
+      def self.from_textual(text, rescue_code:, password: nil, settings: nil, now_ms: nil)
+        s4 = S4Identity.parse_blocks(Textual.decode(text))
+        iuk = s4.unlock_iuk(rescue_code)
+        imk = SQRL::Identity.imk_from_iuk(iuk)
+        previous = s4.type3 ? s4.type3.decrypt(imk) : []
+        unlocked = UnlockedIdentity.from_iuk(iuk, previous)
+        if password
+          kw = now_ms ? { now_ms: now_ms } : {}
+          s4.set_password(unlocked, password, settings || Storage::IdentitySettings.new, **kw)
+        end
+        new(unlocked, s4: s4, iuk: iuk)
+      end
+
+      # Create a brand-new identity. The rescue code is generated unless given and is
+      # available as {#rescue_code}; the S4 file is {#s4} and is written to +path+ when
+      # given.
+      #
+      # @param password [String]
+      # @param rescue_code [String, nil] 24 digits (with or without dashes)
+      # @param settings [SQRL::Storage::IdentitySettings, nil]
+      # @param pw_seconds [Integer, nil] EnScrypt time for the password block (default 5)
+      # @param rescue_seconds [Numeric, nil] EnScrypt time for the rescue block (default 5)
+      # @param path [String, nil]
+      # @param now_ms [#call, nil] clock override (see {.fast_clock}) for fast test identities
+      def self.create(password:, rescue_code: nil, settings: nil, pw_seconds: nil, rescue_seconds: nil,
+                      path: nil, now_ms: nil, &progress)
+        settings ||= Storage::IdentitySettings.new
+        settings = settings.dup.tap { |s| s.pw_verify_seconds = pw_seconds } if pw_seconds
+        rescue_code ||= Storage.generate_rescue_code
+        iuk = Util.random_bytes(32)
+        kw = now_ms ? { now_ms: now_ms } : {}
+        rescue_ms = ((rescue_seconds || 5) * 1000).to_i
+        s4 = S4Identity.create(iuk, password, rescue_code, settings, rescue_ms, **kw, &progress)
+        File.binwrite(path, s4.to_bytes) if path
+        new(UnlockedIdentity.from_iuk(iuk), s4: s4, iuk: iuk, path: path,
+                                            rescue_code: Storage.format_rescue_code(rescue_code))
+      end
+
+      # An identity straight from a 32-byte IUK, skipping EnScrypt and storage entirely.
+      # With no seed the IUK is random; with a seed it is derived deterministically
+      # (32 raw bytes are used as-is, anything else is hashed), which gives reproducible
+      # identities for test suites.
+      def self.ephemeral(seed = nil, previous: [])
+        iuk = case seed
+              when nil then Util.random_bytes(32)
+              when String then seed.b.bytesize == 32 ? seed.b : Crypto.sha256("sqrl-client-ephemeral:#{seed.to_s.b}")
+              else Crypto.sha256("sqrl-client-ephemeral:#{seed.to_s.b}")
+              end
+        new(UnlockedIdentity.from_iuk(iuk, previous), iuk: iuk, previous_iuks: previous)
+      end
+
+      # Build an identity from environment variables:
+      #
+      # * +SQRL_IUK_HEX+ – 64 hex characters: an ephemeral identity (tests, CI)
+      # * +SQRL_IDENTITY_FILE+ with +SQRL_PASSWORD+ or +SQRL_PASSWORD_FILE+ – an S4 file
+      # * +SQRL_RESCUE_CODE+ – optional, recovers the IUK for enable/remove
+      #
+      # @return [Identity, nil] nil when nothing is configured
+      def self.from_env(env = ENV)
+        if (hex = env["SQRL_IUK_HEX"]) && !hex.empty?
+          return ephemeral(Util.hex_decode(hex))
+        end
+
+        file = env["SQRL_IDENTITY_FILE"]
+        return nil if file.nil? || file.empty?
+
+        password = env["SQRL_PASSWORD"]
+        password = File.read(env["SQRL_PASSWORD_FILE"]).chomp if password.nil? && env["SQRL_PASSWORD_FILE"]
+        raise IdentityLocked, "SQRL_PASSWORD or SQRL_PASSWORD_FILE is required with SQRL_IDENTITY_FILE" if password.nil?
+
+        load(file, password: password, rescue_code: env["SQRL_RESCUE_CODE"])
+      end
+
+      # @api private
+      def initialize(unlocked, s4: nil, iuk: nil, path: nil, rescue_code: nil, previous_iuks: nil)
+        @unlocked = unlocked
+        @s4 = s4
+        @iuk = iuk&.b
+        @path = path
+        @rescue_code = rescue_code
+        @previous_iuks = previous_iuks || unlocked.previous_iuks
+      end
+
+      # The Identity Unlock Key when it is known (ephemeral identities, freshly created
+      # ones, or after {#unlock_iuk!}); nil otherwise.
+      attr_reader :iuk
+
+      # Whether +enable+/+remove+/+rekey!+ can run without a rescue code.
+      def iuk? = !@iuk.nil?
+
+      # Recover the IUK from the identity file's rescue block (slow: EnScrypt).
+      #
+      # @return [String] the IUK
+      def unlock_iuk!(rescue_code)
+        return @iuk if @iuk
+
+        raise IdentityLocked, "this identity has no rescue block; the IUK cannot be recovered" unless @s4&.rescue_block?
+
+        iuk = @s4.unlock_iuk(rescue_code)
+        raise CryptoError, "rescue code does not belong to this identity" unless @unlocked.matches_iuk?(iuk)
+
+        @iuk = iuk
+      end
+
+      # Re-key: a fresh IUK replaces the current one and the current one becomes the most
+      # recent previous identity, exactly as a SQRL client's "rekey identity" does. Needs the
+      # current IUK (ephemeral/created identities have it; file identities need
+      # +rescue_code:+). File-backed identities are re-encrypted under +password:+ (and a new
+      # rescue code, available as {#rescue_code}); the file at {#path} is rewritten.
+      #
+      # @return [self]
+      def rekey!(password: nil, rescue_code: nil, new_rescue_code: nil, settings: nil, now_ms: nil, rescue_seconds: nil)
+        old_iuk = @iuk || (rescue_code && unlock_iuk!(rescue_code))
+        raise IdentityLocked, "re-keying needs the current IUK (rescue code)" unless old_iuk
+
+        new_iuk = Util.random_bytes(32)
+        if @s4
+          raise ArgumentError, "password: is required to re-key a file-backed identity" unless password
+
+          new_rescue_code ||= Storage.generate_rescue_code
+          kw = now_ms ? { now_ms: now_ms } : {}
+          rescue_ms = ((rescue_seconds || 5) * 1000).to_i
+          @unlocked = @s4.rekey(@unlocked, old_iuk, new_iuk, password, new_rescue_code,
+                                settings || @s4.settings, rescue_ms, **kw)
+          @rescue_code = Storage.format_rescue_code(new_rescue_code)
+          File.binwrite(@path, @s4.to_bytes) if @path
+        else
+          previous = ([old_iuk] + @unlocked.previous_iuks).first(Storage::MAX_PREVIOUS_KEYS)
+          @unlocked = UnlockedIdentity.from_iuk(new_iuk, previous)
+        end
+        @iuk = new_iuk
+        self
+      end
+
+      # A detached copy of this identity as it was before the most recent {#rekey!}:
+      # handy for testing that a superseded identity is refused.
+      def previous_identity(index = 0)
+        iuk = @unlocked.previous_iuks[index]
+        return nil unless iuk
+
+        self.class.ephemeral(iuk)
+      end
+
+      # @return [Integer] number of previous identities carried
+      def previous_count = @unlocked.previous_count
+
+      # 16 hex characters identifying the identity without revealing key material.
+      def fingerprint = @unlocked.fingerprint
+
+      # Save the identity file (requires an S4-backed identity).
+      def save(path = @path)
+        raise IdentityLocked, "ephemeral identities have no file to save" unless @s4
+        raise ArgumentError, "no path given" unless path
+
+        File.binwrite(path, @s4.to_bytes)
+        @path = path
+      end
+
+      # The identity file as +SQRLDATA+ text, or the IUK in hex for ephemeral identities
+      # (both forms load back with {.load}/{.from_env}).
+      def export
+        @s4 ? @s4.to_text : Util.hex_encode(@iuk)
+      end
+
+      # @return [String] a short description with secret material redacted
+      def inspect
+        "#<SQRL::Client::Identity fingerprint=#{fingerprint} iuk=#{iuk? ? "known" : "locked"} " \
+          "previous=#{previous_count}#{" path=#{@path}" if @path}>"
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/sqrl/client/transport.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "http-cookie"
+
+module SQRL
+  module Client
+    # The HTTP layer: Net::HTTP with a persistent cookie jar, redirects, timeouts and the
+    # plain-http policy SQRL needs (+https+ everywhere, +http+ only for loopback hosts
+    # while developing).
+    #
+    # Anything responding to +get(url, headers)+ and +post_form(url, body, headers)+ and
+    # returning a {Response} can replace it (for example a Faraday adapter).
+    class Transport
+      # An HTTP response after redirects were followed.
+      Response = Struct.new(:status, :headers, :body, :final_url, :redirects, keyword_init: true) do
+        def success? = (200..299).cover?(status)
+        def redirect? = (300..399).cover?(status)
+
+        # @return [String, nil] a response header by name (case-insensitive)
+        def [](name) = headers[name.to_s.downcase]
+
+        # @return [Object] the body parsed as JSON
+        # @raise [JSON::ParserError]
+        def json
+          require "json"
+          JSON.parse(body)
+        rescue JSON::ParserError
+          nil
+        end
+
+        # @return [String] a short description with secret material redacted
+        def inspect
+          "#<SQRL::Client::Transport::Response #{status} #{final_url}>"
+        end
+      end
+
+      # HTTP statuses followed as redirects.
+      REDIRECT_STATUSES = [301, 302, 303, 307, 308].freeze
+      # User-Agent sent with every request.
+      DEFAULT_USER_AGENT = "sqrl-client/#{SQRL::VERSION} (Ruby #{RUBY_VERSION})".freeze
+
+      # @return [HTTP::CookieJar]
+      attr_reader :cookies
+      attr_accessor :open_timeout, :read_timeout, :max_redirects, :user_agent, :logger
+
+      # @param cookies [HTTP::CookieJar] shared cookie jar
+      # @param allow_http [Symbol, Boolean] +false+ (default) never speaks plain http;
+      #   +:loopback+ permits it for loopback hosts only (testing); +true+ everywhere
+      # @param verify_tls [Boolean]
+      # @param ca_file [String, nil]
+      # @param proxy [String, nil, :env] proxy URL; +:env+ (default) honours +http_proxy+ /
+      #   +https_proxy+ / +no_proxy+; loopback hosts never go through a proxy
+      def initialize(cookies: HTTP::CookieJar.new, allow_http: false, verify_tls: true, ca_file: nil,
+                     proxy: :env, open_timeout: 10, read_timeout: 30, max_redirects: 10,
+                     user_agent: DEFAULT_USER_AGENT, logger: nil)
+        @cookies = cookies
+        @allow_http = allow_http
+        @verify_tls = verify_tls
+        @ca_file = ca_file
+        @proxy = proxy
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+        @max_redirects = max_redirects
+        @user_agent = user_agent
+        @logger = logger
+      end
+
+      # GET +url+, following redirects with the cookie jar.
+      def get(url, headers = {}, follow_redirects: true)
+        request(:get, url, nil, headers, follow_redirects: follow_redirects)
+      end
+
+      # POST an +application/x-www-form-urlencoded+ body (already encoded).
+      def post_form(url, body, headers = {}, follow_redirects: true)
+        headers = { "Content-Type" => "application/x-www-form-urlencoded" }.merge(headers)
+        request(:post, url, body, headers, follow_redirects: follow_redirects)
+      end
+
+      # Remove every cookie (a fresh "browser").
+      def clear_cookies!
+        @cookies.clear
+        self
+      end
+
+      # Cookies in Netscape +cookies.txt+ format (what curl reads with +-b+).
+      def cookies_netscape
+        lines = ["# Netscape HTTP Cookie File"]
+        @cookies.each do |c|
+          domain = c.for_domain? ? ".#{c.domain}" : c.domain
+          expires = c.expires ? c.expires.to_i : 0
+          lines << [domain, c.for_domain? ? "TRUE" : "FALSE", c.path, c.secure? ? "TRUE" : "FALSE",
+                    expires, c.name, c.value].join("\t")
+        end
+        "#{lines.join("\n")}\n"
+      end
+
+      # Cookies as an Array of Hashes (serialisable to JSON).
+      def cookies_as_hashes
+        @cookies.map do |c|
+          { name: c.name, value: c.value, domain: c.domain, path: c.path, secure: c.secure?,
+            httponly: c.httponly?, expires: c.expires&.iso8601 }
+        end
+      end
+
+      private
+
+      def request(method, url, body, headers, follow_redirects:, redirects: 0)
+        uri = URI.parse(url.to_s)
+        check_scheme!(uri)
+        http = build_http(uri)
+        req = build_request(method, uri, body, headers)
+        @logger&.debug { "[sqrl-client] #{method.to_s.upcase} #{uri}" }
+        res = http.start { |h| h.request(req) }
+        store_cookies(res, uri)
+        status = res.code.to_i
+        if follow_redirects && REDIRECT_STATUSES.include?(status) && res["location"]
+          raise TransportError.new("too many redirects", url: url) if redirects >= @max_redirects
+
+          target = uri.merge(res["location"]).to_s
+          next_method = [307, 308].include?(status) ? method : :get
+          next_body = next_method == :get ? nil : body
+          next_headers = next_method == :get ? headers.reject { |k, _| k.to_s.casecmp?("content-type") } : headers
+          return request(next_method, target, next_body, next_headers, follow_redirects: true,
+                                                                       redirects: redirects + 1)
+        end
+        Response.new(status: status, headers: res.each_header.to_h, body: res.body.to_s,
+                     final_url: uri.to_s, redirects: redirects)
+      rescue SystemCallError, Timeout::Error, OpenSSL::SSL::SSLError, SocketError, EOFError, Net::ProtocolError => e
+        raise TransportError.new("#{method.to_s.upcase} #{url}: #{e.class}: #{e.message}", url: url)
+      end
+
+      def check_scheme!(uri)
+        case uri.scheme
+        when "https" then nil
+        when "http"
+          allowed = @allow_http == true || (@allow_http == :loopback && URL.loopback?(uri.host.to_s.downcase))
+          unless allowed
+            raise TransportError.new("plain http is not allowed for #{uri.host} (allow_http: #{@allow_http.inspect})",
+                                     url: uri.to_s)
+          end
+        else
+          raise TransportError.new("unsupported URL scheme #{uri.scheme.inspect}", url: uri.to_s)
+        end
+      end
+
+      def build_http(uri)
+        http =
+          if URL.loopback?(uri.host.to_s.downcase) || @proxy.nil?
+            Net::HTTP.new(uri.host, uri.port, nil)
+          elsif @proxy == :env
+            Net::HTTP.new(uri.host, uri.port)
+          else
+            p = URI.parse(@proxy.to_s)
+            Net::HTTP.new(uri.host, uri.port, p.host, p.port, p.user, p.password)
+          end
+        http.open_timeout = @open_timeout
+        http.read_timeout = @read_timeout
+        if uri.scheme == "https"
+          http.use_ssl = true
+          http.verify_mode = @verify_tls ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+          http.ca_file = @ca_file if @ca_file
+        end
+        http
+      end
+
+      def build_request(method, uri, body, headers)
+        klass = method == :post ? Net::HTTP::Post : Net::HTTP::Get
+        req = klass.new(uri.request_uri)
+        req["User-Agent"] = @user_agent
+        req["Accept"] ||= "*/*"
+        headers.each { |k, v| req[k.to_s] = v }
+        cookie = HTTP::Cookie.cookie_value(@cookies.cookies(uri))
+        req["Cookie"] = cookie unless cookie.empty?
+        req.body = body if body
+        req
+      end
+
+      def store_cookies(res, uri)
+        res.get_fields("set-cookie")&.each do |value|
+          HTTP::Cookie.parse(value, uri).each { |c| @cookies.add(c) }
+        rescue StandardError => e
+          @logger&.warn { "[sqrl-client] ignoring unparsable cookie: #{e.message}" }
+        end
+      end
+    end
+  end
+end

data/lib/sqrl/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "sqrl/core"
+require_relative "client/errors"
+require_relative "client/identity"
+require_relative "client/transport"
+require_relative "client/discovery"
+require_relative "client/agent"
+
+# SQRL namespace, reopened for the client.
+module SQRL
+  # A bot-capable SQRL client: everything a script, a test suite or an automated service
+  # needs to log in to a SQRL-enabled website without a browser or a human.
+  #
+  #   identity = SQRL::Client::Identity.load("bot.sqrl", password: ENV["SQRL_PASSWORD"])
+  #   agent    = SQRL::Client::Agent.new(identity: identity)
+  #   result   = agent.login("https://example.com/login")
+  #   result.authenticated?  # => true
+  #   agent.http.get("https://example.com/account")  # carries the logged-in cookies
+  module Client
+    autoload :Capybara, "sqrl/client/capybara"
+    autoload :Conformance, "sqrl/client/conformance"
+    autoload :CLI, "sqrl/client/cli"
+
+    # Version of the client gem (released in lockstep with sqrl-core).
+    VERSION = SQRL::VERSION
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: sqrl-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel P. Clark
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http-cookie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: sqrl-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: Identity management, the full SQRL command set, CPS handoff, login-page
+  discovery, a Capybara helper, a CLI and a server conformance suite.
+email:
+- 6ftdan@gmail.com
+executables:
+- sqrl-client
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- exe/sqrl-client
+- lib/sqrl/client.rb
+- lib/sqrl/client/agent.rb
+- lib/sqrl/client/capybara.rb
+- lib/sqrl/client/cli.rb
+- lib/sqrl/client/conformance.rb
+- lib/sqrl/client/conformance/report.rb
+- lib/sqrl/client/conformance/rspec.rb
+- lib/sqrl/client/conformance/runner.rb
+- lib/sqrl/client/conformance/site.rb
+- lib/sqrl/client/discovery.rb
+- lib/sqrl/client/errors.rb
+- lib/sqrl/client/identity.rb
+- lib/sqrl/client/transport.rb
+homepage: https://github.com/danielpclark/sqrl-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/danielpclark/sqrl-ruby
+  source_code_uri: https://github.com/danielpclark/sqrl-ruby/tree/main/gems/sqrl-client
+  changelog_uri: https://github.com/danielpclark/sqrl-ruby/blob/main/gems/sqrl-client/CHANGELOG.md
+  bug_tracker_uri: https://github.com/danielpclark/sqrl-ruby/issues
+  documentation_uri: https://github.com/danielpclark/sqrl-ruby/blob/main/gems/sqrl-client/README.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'Bot-capable SQRL client: log in to SQRL-enabled websites from scripts and
+  test suites'
+test_files: []