kiosk-server 0.5.20 → 0.6.28

data/lib/kiosk/server/jwks.rb

@@ -9,6 +9,12 @@ module Kiosk
       def build(keys:)
         { keys: Array(keys).map(&:to_jwk) }
       end
+
+      # The public key of the JWK in `jwks` whose `kid` is `kid`, or nil.
+      def find(jwks, kid)
+        jwk = Array(jwks[:keys] || jwks['keys']).find { |k| (k[:kid] || k['kid']) == kid }
+        jwk && Jwk.import(jwk)
+      end
     end
   end
 end

data/lib/kiosk/server/jwt_issuer.rb

@@ -5,16 +5,12 @@ require 'securerandom'
 
 module Kiosk
   module Server
-    # Issues and verifies the RS256 access tokens of the bundled kiosk-pop IdP.
+    # Issues and verifies the EdDSA access tokens of the bundled agent IdP.
     module JwtIssuer
-      ALGORITHM = 'RS256'
+      ALGORITHM = Eddsa::NAME
       DEFAULT_EXPIRES_IN = 3600
       DEFAULT_LEEWAY = 60
 
-      # A `kid` not in the JWKS: the signature cannot be checked.
-      UNKNOWN_KID = ->(e) { e.message.include?('public key for kid') || e.message.include?('Could not find public key') }
-      private_constant :UNKNOWN_KID
-
       class Error < StandardError; end
       class SignatureError < Error; end
       class ExpiredError < Error; end
@@ -33,7 +29,7 @@ module Kiosk
         raise ArgumentError, 'signing_key must carry a private key for issuance' unless signing_key.private?
 
         payload = registered_claims(claims, issuer: issuer, audience: audience, issued_at: now.to_i, expires_in: expires_in)
-        ::JWT.encode(payload, signing_key.rsa, ALGORITHM, { kid: signing_key.kid, typ: 'JWT' })
+        ::JWT.encode(payload, signing_key.key, ALGORITHM, { kid: signing_key.kid, typ: 'JWT' })
       end
 
       def verify(token:, jwks:, audience: nil, issuer: nil, leeway: DEFAULT_LEEWAY)
@@ -58,9 +54,9 @@ module Kiosk
       def decode(token, jwks, audience:, issuer:, leeway:)
         decoded, = ::JWT.decode(
           token, nil, true,
-          jwks: jwks, algorithms: [ALGORITHM], aud: audience, iss: issuer,
+          algorithms: [ALGORITHM], aud: audience, iss: issuer,
           verify_aud: !audience.nil?, verify_iss: !issuer.nil?, leeway: leeway
-        )
+        ) { |header| Jwks.find(jwks, header['kid']) || raise(SignatureError, 'no key of the JWKS has this kid') }
         symbolize(decoded)
       rescue ::JWT::DecodeError => e
         raise error_class_for(e), e.message
@@ -70,7 +66,7 @@ module Kiosk
         case error
         when ::JWT::ExpiredSignature then ExpiredError
         when ::JWT::InvalidAudError then AudienceError
-        when ::JWT::VerificationError, ::JWT::IncorrectAlgorithm, UNKNOWN_KID then SignatureError
+        when ::JWT::VerificationError, ::JWT::IncorrectAlgorithm then SignatureError
         else InvalidError
         end
       end
@@ -88,9 +84,7 @@ module Kiosk
         end
       end
 
-      def symbolize(hash)
-        hash.each_with_object({}) { |(k, v), out| out[k.to_sym] = v }
-      end
+      def symbolize(hash) = hash.deep_symbolize_keys
 
       private_class_method :registered_claims, :decode, :error_class_for
     end

data/lib/kiosk/server/kyc.rb

@@ -49,7 +49,7 @@ module Kiosk
         def claims = Array(Kiosk.configuration.kyc_claims).map(&:to_s)
 
         def served!
-          return if provider
+          return if provider&.opens_verifications?
 
           raise Errors::ModuleNotServed.new(
             'this operator does not serve the KYC module',
@@ -115,8 +115,8 @@ module Kiosk
 
         # Names only a path this origin serves.
         def gate_hint
-          return REQUEST_HINT if provider
-          return ATTEST_HINT if Kiosk.configuration.kyc_public_key
+          return REQUEST_HINT if provider&.opens_verifications?
+          return ATTEST_HINT if provider
 
           CLOSED_HINT
         end
@@ -148,9 +148,7 @@ module Kiosk
           private
 
           def open_verification(user_id)
-            Kyc.provider.open_verification(subject: user_id, claims: Kyc.claims,
-                                           audience: Kiosk.configuration.kyc_audience.to_s,
-                                           callback_url: Kyc.callback_url)
+            Kyc.provider.open_verification(subject: user_id, claims: Kyc.claims, callback_url: Kyc.callback_url)
           rescue Kiosk::KycProviders::Unavailable => e
             FailureLog.report("#{NAME} could not open a verification", e)
             raise Errors::WireError.new(
@@ -249,7 +247,7 @@ module Kiosk
                     JSON.generate(attributes), user_id.to_s)
           end
 
-          def table(name) = connection.quote_table_name("#{Kiosk.configuration.schema}.#{name}")
+          def table(name) = connection.quote_table_name("#{Kiosk.configuration.schema}.kiosk_#{name}")
 
           def execute(sql, *binds) = connection.exec_query(sql, 'Kiosk KYC', binds).to_a
 

data/lib/kiosk/server/kyc_verifier.rb

@@ -4,14 +4,14 @@ require 'jwt'
 
 module Kiosk
   module Server
-    # Verifies a KYC attestation JWS against `kyc_public_key`: `iss`, `aud`,
-    # `sub` and `level: "verified"` must match, and the configured
-    # `kyc_provider` must accept it; only attributes
-    # that are literally `true` are granted.
+    # Verifies a KYC attestation JWS against the configured `kyc_provider`: its
+    # key signs it, its `iss` and `aud` match, `sub` and `level: "verified"`
+    # match, and the provider accepts it; only attributes that are literally
+    # `true` are granted.
     module KycVerifier
       # Named once for the decode and the published hint.
       REQUIRED_CLAIMS = %w[exp iss aud sub].freeze
-      SIGNATURE_HINT  = 'an attestation is a compact RS256 JWS signed by the issuer this origin ' \
+      SIGNATURE_HINT  = 'an attestation is a compact EdDSA JWS signed by the issuer this origin ' \
                         'is configured to trust'
       SUBJECT_HINT    = "sub must name the principal: the caller's at POST <endpoint>/agents/kyc, " \
                         "the open verification's at the callback"
@@ -19,17 +19,17 @@ module Kiosk
       module_function
 
       def verify(raw_jws:, subject:)
-        config  = Kiosk.configuration
-        payload = decode(raw_jws, config)
-        check_issuer!(payload, config)
+        provider = provider!
+        payload  = decode(raw_jws, provider)
+        check_issuer!(payload, provider)
         # Binds the attestation to this operator.
-        if payload[:aud].to_s != config.kyc_audience.to_s
+        if payload[:aud].to_s != provider.audience
           raise Errors::Forbidden.new('KYC attestation audience mismatch',
-                                      hint: audience_hint(payload, config))
+                                      hint: audience_hint(payload, provider))
         end
 
         check_subject!(payload, subject)
-        check_provider!(payload, config)
+        check_provider!(payload, provider)
 
         payload.merge(attributes: verified_attributes(payload[:attributes]))
       end
@@ -47,9 +47,9 @@ module Kiosk
       end
 
       # The verified payload with symbol keys.
-      def decode(raw_jws, config)
-        payload, = ::JWT.decode(raw_jws, public_key!(config), true,
-                                algorithms: ['RS256'], verify_expiration: true, required_claims: REQUIRED_CLAIMS)
+      def decode(raw_jws, provider)
+        payload, = ::JWT.decode(raw_jws, provider.public_key, true,
+                                algorithms: [Eddsa::NAME], verify_expiration: true, required_claims: REQUIRED_CLAIMS)
         payload.transform_keys(&:to_sym)
       rescue ::JWT::ExpiredSignature
         raise Errors::Forbidden, 'KYC attestation expired'
@@ -59,30 +59,30 @@ module Kiosk
         raise Errors::Forbidden.new('KYC attestation signature invalid', hint: SIGNATURE_HINT)
       end
 
-      # Refused when this origin trusts no KYC issuer.
-      def public_key!(config)
-        key = config.kyc_public_key
-        return key unless key.nil?
+      # Refused when this origin trusts no KYC provider.
+      def provider!
+        provider = Kiosk.configuration.kyc_provider
+        return provider unless provider.nil?
 
         raise Errors::ModuleNotServed.new(
           'this operator does not serve the KYC module',
           hint: 'no KYC attestation is accepted at this origin; retrying will not help. ' \
-                'An operator that means to serve KYC sets Kiosk.configuration.kyc_public_key.'
+                'An operator that means to serve KYC sets Kiosk.configuration.kyc_provider.'
         )
       end
 
-      def check_issuer!(payload, config)
-        return if payload[:iss] == config.kyc_issuer
+      def check_issuer!(payload, provider)
+        return if payload[:iss] == provider.issuer
 
         raise Errors::Forbidden.new(
           'KYC attestation issuer mismatch',
-          hint: "expected #{config.kyc_issuer.inspect}, got #{payload[:iss].inspect}"
+          hint: "expected #{provider.issuer.inspect}, got #{payload[:iss].inspect}"
         )
       end
 
-      def audience_hint(payload, config)
-        "aud must equal this operator's kyc_audience " \
-          "(expected #{config.kyc_audience.inspect}, got #{payload[:aud].inspect})"
+      def audience_hint(payload, provider)
+        "aud must equal the audience this operator's KYC provider mints " \
+          "(expected #{provider.audience.inspect}, got #{payload[:aud].inspect})"
       end
 
       # Subject and level. A bigint-PK host's subject is an Integer.
@@ -93,14 +93,13 @@ module Kiosk
       end
 
       # The provider's own checks ({Kiosk::KycProviders::Base#accepts?}).
-      def check_provider!(payload, config)
-        provider = config.kyc_provider
-        return if provider.nil? || provider.accepts?(payload.transform_keys(&:to_s))
+      def check_provider!(payload, provider)
+        return if provider.accepts?(payload.transform_keys(&:to_s))
 
         raise Errors::Forbidden, 'the KYC provider does not accept this attestation at this operator'
       end
 
-      private_class_method :decode, :public_key!, :check_issuer!, :audience_hint, :check_subject!, :check_provider!
+      private_class_method :decode, :provider!, :check_issuer!, :audience_hint, :check_subject!, :check_provider!
     end
   end
 end

data/lib/kiosk/server/link_code.rb

@@ -4,7 +4,7 @@ module Kiosk
   module Server
     # Account binding started by the human: the signed-in holder mints a
     # single-use link code ({.mint}, POST /auth/link) and their assistant
-    # redeems it with its key, a possession proof and the auth toll ({.redeem}, POST /auth/claim).
+    # redeems it with a client assertion and the auth toll ({.redeem}, POST /auth/claim).
     module LinkCode
       CLIENT_ID = 'kiosk-link'
 
@@ -31,37 +31,28 @@ module Kiosk
       end
 
       # The toll comes before the lookup, so an unknown code costs the same work as a live one.
-      def redeem(code:, public_key_pem:, signed:, pow: nil, # rubocop:disable Metrics/ParameterLists -- the claim controller and the specs pass these by name
+      #
+      # @return [Client] the client under the account of the human who minted the code
+      # @raise [ClientAssertion::Refused] the client assertion is refused
+      def redeem(code:, assertion_type:, assertion:, pow: nil, # rubocop:disable Metrics/ParameterLists -- the claim controller and the specs pass these by name
                  store: Kiosk.configuration.device_authorization_store,
                  now: Time.current)
         raise Errors::BadRequest, 'code required' if code.to_s.empty?
 
-        pem = public_key_pem.to_s.strip
-        PopVerifier.load_public_key(pem)
-        AuthToll.gate(verb: 'auth/claim', body: { code: code.to_s, public_key: pem }, pow: pow)
+        AuthToll.gate(verb: 'auth/claim', body: { code: code.to_s }, pow: pow)
         da = live_link(store, code.to_s, now)
 
-        # The proof comes before the consume, so a failed one leaves the code live.
-        prove_possession!(pem, signed)
+        # The client authenticates before the consume, so a refused assertion leaves the code live.
+        client = ClientAssertion.authenticate!(assertion_type, assertion)
         # The atomic consume, not `consumed?` below, decides single use under a race.
         raise Errors::Conflict, 'link code already used' if store.claim_consume(da, now: now).nil?
 
-        bind(pem, da)
+        AccountBinding.bind!(agent_id: client.id, user_id: da.user_id, requested_role: da.requested_role)
       end
 
       class << self
         private
 
-        def prove_possession!(pem, signed)
-          payload = PopVerifier.verify!(public_key_pem: pem, signed: signed)
-          AuthChallenge.consume!(public_key_pem: pem, nonce: payload.fetch(:nonce))
-        end
-
-        def bind(pem, link)
-          result = AccountBinding.bind!(public_key_pem: pem, user_id: link.user_id, requested_role: link.requested_role)
-          { agent_id: result[:agent_id], user_id: result[:user_id], access_token: result[:access_token] }
-        end
-
         def live_link(store, code, now)
           da = store.lookup_by_device_code_hash(DeviceAuthorization.hash_device_code(code))
           unless da&.link?

data/lib/kiosk/server/linked_assistants.rb

@@ -34,7 +34,7 @@ module Kiosk
 
         def settings_sql(assignments, bind_count)
           <<~SQL.squish
-            UPDATE #{Kiosk.configuration.schema}.agents
+            UPDATE #{Kiosk.configuration.schema}.kiosk_agents
             SET #{assignments.join(', ')}
             WHERE id = $#{bind_count - 2}
               AND user_id = $#{bind_count - 1}
@@ -47,18 +47,16 @@ module Kiosk
 
         def agents_sql
           <<~SQL.squish
-            SELECT id, public_key, created_at, human_label, spending_cap_cents, spending_cap_currency
-            FROM #{Kiosk.configuration.schema}.agents
+            SELECT id, public_key, bound_at, human_label, spending_cap_cents, spending_cap_currency
+            FROM #{Kiosk.configuration.schema}.kiosk_agents
             WHERE user_id = $1 AND issuer = $2 AND revoked_at IS NULL
             ORDER BY created_at
           SQL
         end
 
-        # `{ agent_id => { currency => cents } }`: the figure the spending cap
-        # counts, within `spending_cap_window_days` when set.
+        # `{ agent_id => { currency => cents } }`: what each agent spent.
         def spend_by_agent(user_id)
-          window_days = Kiosk.configuration.spending_cap_window_days&.to_i
-          tally(run(spend_sql(window_days), 'Kiosk assistant spend', [user_id, Kiosk.current_issuer, *window_days]))
+          tally(run(spend_sql, 'Kiosk assistant spend', [user_id, Kiosk.current_issuer]))
         rescue ::ActiveRecord::StatementInvalid => e
           raise unless missing_table?(e)
 
@@ -71,20 +69,27 @@ module Kiosk
           end
         end
 
-        # The day count, when set, is the third bind.
-        def spend_sql(window_days)
+        # One tally per currency.
+        def spend_sql
           schema = Kiosk.configuration.schema
-          window = window_days ? 'AND settlements.settled_at >= now() - make_interval(days => $3)' : ''
           <<~SQL.squish
-            SELECT settlements.agent_id, lower(btrim(settlements.currency)) AS currency,
-                   SUM(#{SettledSpend.net_cents_sql(schema)}) AS cents
-            FROM #{schema}.settlements
-            JOIN #{schema}.agents ON agents.id = settlements.agent_id
-            WHERE agents.user_id = $1 AND agents.issuer = $2 AND agents.revoked_at IS NULL #{window}
+            SELECT settlements.agent_id, lower(btrim(settlements.currency)) AS currency, SUM(#{net_cents_sql(schema)}) AS cents
+            FROM #{schema}.kiosk_settlements settlements
+            JOIN #{schema}.kiosk_agents agents ON agents.id = settlements.agent_id
+            WHERE agents.user_id = $1 AND agents.issuer = $2 AND agents.revoked_at IS NULL
             GROUP BY 1, 2 ORDER BY 2
           SQL
         end
 
+        # Each settlement less what was refunded of it, never below zero.
+        def net_cents_sql(schema)
+          <<~SQL.squish
+            GREATEST(settlements.settled_amount_cents - (
+              SELECT COALESCE(SUM(r.refunded_amount_cents), 0) FROM #{schema}.kiosk_refunds r WHERE r.settlement_id = settlements.id
+            ), 0)
+          SQL
+        end
+
         # By class name, so this file does not load `PG`.
         def missing_table?(error)
           error.cause&.class&.name == 'PG::UndefinedTable'
@@ -95,7 +100,7 @@ module Kiosk
           {
             agent_id: row.fetch('id'),
             fingerprint: fingerprint(row.fetch('public_key')),
-            created_at: row.fetch('created_at'),
+            bound_at: row.fetch('bound_at', nil),
             human_label: row.fetch('human_label', nil),
             spending_cap_cents: cap&.to_i,
             spending_cap_currency: row.fetch('spending_cap_currency', nil),
@@ -106,7 +111,7 @@ module Kiosk
         def fingerprint(pem)
           return '(no key)' if pem.blank?
 
-          SigningKey.from_pem(pem).kid
+          AssistantKey.thumbprint(AssistantKey.from_pem(pem))
         rescue StandardError
           '(unreadable key)'
         end