kiosk-test-support 0.5.20 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82f1f47c2715da7a7ef6897038c156d7033991f159d7dea50446ee3af8933d01
-  data.tar.gz: 0b06db9324f1ea8d0e7e11036f756db6e4eef3fffc9899961506e95f0f999183
+  metadata.gz: 7c7eb9fc194090087a2bd0a1b771861d165f3fea55a0fbfd832ba2d1d0037a08
+  data.tar.gz: a862919840551f535559671b236ac98a84dc420e07dba3c706c30d105032b4a8
 SHA512:
-  metadata.gz: 4b1c2beec651bb6bb2836c28cb5440903d113867d91f33bce3bdd42625c5d34336b0916332e39b3d92b60d5633668074decb3c5c2169597fd6c036c7b274595f
-  data.tar.gz: 66c9376f8e27a37bd455f503fa34f1617d8e7e790eb348fc44075494cc81e386f9e1ec23593a86f011781ec537909ec5a14a2feba01f7cb4fa4cee1684ccbbc9
+  metadata.gz: 49f01347f6643ef9032955d55064c8555000336efa5a507073d29e16cd41e2c12cd851407b59ac4bc74e1c4c9dd6272e0c9cbe75aada517746c4484f8d0783ad
+  data.tar.gz: dbe42526621ccd03a3153db7d2ed4338892915d8b6cd2975478eb4079e8034c7edcbf7a083298f5cab0f3b13e8337bf8cbe3d9a9e935b13ea8cfc53dfa38a622

data/CHANGELOG.md

@@ -12,6 +12,48 @@ already written is edited.
 
 ## [Unreleased]
 
+## [0.6.1] — 2026-10-22
+
+- 2026-10-22: Version 0.6.1, the tree cut that matches skill 0.6.1.
+- 2026-10-21: Drops the `kiosk-pow-equihash` and `puma` dependencies; the host's bundle brings them. `Wire` names the gem to add, and refuses a toll in another proof of work.
+
+## [0.6.0] — 2026-10-21
+
+- 2026-10-21: The helpers make Ed25519 assistant keys and sign EdDSA; `Principal#key` replaces `#rsa_key`, and `Dpop.generate_key('ES256')` makes a P-256 key.
+- 2026-10-21: Version 0.6.0, the tree cut that matches skill 0.6.0.
+
+## [0.5.27] — 2026-10-21
+
+- 2026-10-21: `Assistant` registers at `/kiosk/oauth/register` and gets tokens by client assertion and DPoP; `login`, `proof_of_possession` and the challenge are gone.
+- 2026-10-21: Version 0.5.27, the tree cut that matches skill 0.5.27.
+
+## [0.5.26] — 2026-10-21
+
+- 2026-10-21: Version 0.5.26, the tree cut that matches skill 0.5.26.
+
+## [0.5.25] — 2026-10-21
+
+- 2026-10-21: Version 0.5.25, the tree cut that matches skill 0.5.25.
+
+## [0.5.24] — 2026-10-21
+
+- 2026-10-21: The gemspec depends on kiosk-server and kiosk-user-idp-devise, which the in-process helpers and `Person` require, so a bundle with this gem alone loads them.
+- 2026-10-21: Version 0.5.24, the tree cut that matches skill 0.5.24.
+
+## [0.5.23] — 2026-10-21
+
+- 2026-10-21: `Wire#dpop` replaces `Wire#bearer`: each call sends the token as `Authorization: DPoP` with a new proof. `Assistant#rotate` puts a new key on a principal.
+- 2026-10-21: Version 0.5.23, the tree cut that matches skill 0.5.23.
+
+## [0.5.22] — 2026-10-21
+
+- 2026-10-21: `Kiosk::TestHelpers::Mandate` signs the two AP2 v0.2 mandates; `Assistant#pay` and `Customer#pays` take a `checkout_jwt`.
+- 2026-10-21: Version 0.5.22, the tree cut that matches skill 0.5.22.
+
+## [0.5.21] — 2026-10-21
+
+- 2026-10-21: Version 0.5.21, the tree cut that matches skill 0.5.21.
+
 ## [0.5.20] — 2026-10-20
 
 - 2026-10-20: `InProcessOrigin` and `InProcessExecutor` call a verb through its route with a linked assistant's token; `InProcessWire` does the call.

data/README.md

@@ -29,6 +29,8 @@ end
 
 Both harnesses pull `kiosk-test-support` as a transitive dependency.
 
+Your bundle brings what the helpers drive: `puma` for `LiveServer` (`rails new` writes it), and `kiosk-pow-equihash` for the solver that pays Equihash tolls. `Wire` solves no other proof of work.
+
 ## DSL
 
 ```ruby
@@ -69,7 +71,7 @@ The `NullExecutor` is the zero-dependency fallback for unit-shaped tests; produc
 
 ## Driving the wire as an assistant
 
-`Kiosk::TestHelpers::Assistant` registers, pays proof-of-work tolls, queries, runs, pays with signed mandates and listens on `<endpoint>/events`, against any origin — a test's own live server or a deployment:
+`Kiosk::TestHelpers::Assistant` registers its key as an OAuth client and gets DPoP-bound tokens, pays proof-of-work tolls, queries, runs, pays with closed AP2 mandates (SD-JWT) and listens on `<endpoint>/events`, against any origin — a test's own live server or a deployment:
 
 ```ruby
 require "kiosk/test_helpers/assistant"
@@ -90,7 +92,7 @@ Every answer carries its status, parsed body and headers. `Kiosk::TestHelpers::W
 ```ruby
 class Shopper < Kiosk::TestHelpers::Customer
   def orders(*skus) = does(:create_order, items: skus.map { { sku: _1, qty: 1 } })
-  def pays_for(order) = pays(total: order["total_cents"], scope: "grocery", line_items: [{ order_id: order["order_id"] }])
+  def pays_for(order) = pays(order["checkout_jwt"])
 end
 
 class ShopStory < Kiosk::StoryTest
@@ -101,11 +103,11 @@ class ShopStory < Kiosk::StoryTest
 end
 ```
 
-- `a_customer(as:)` registers an assistant; `a_newcomer(as:)` holds a key and no account yet; `published(path)` reads what the origin shows anyone.
+- `a_customer(as:)` registers an assistant; `a_newcomer(as:)` registers a key and acts for no person yet; `published(path)` reads what the origin shows anyone.
 - `Customer#asks` and `#does` answer an `Answer` (`ok?`, `refused?(code)`, `detail`, `hint`, `rows`, `header`, `tolls_paid`, `solved_toll`, `next_page`); `asks(…, unpaid: true)` or `asks(…, proofs: […])` leaves the toll to the story.
 - `Kiosk::StoryTest#assert_refused(answer, code)` asserts the wire refused the `Answer` with `code`.
-- `Customer#sets_up_payment` and `#requests_verification` run the engine's `payment_setup` and `request_kyc`, and `#hears_verification_passed` waits for the outcome of the check it asked for last; `#pays(total:, scope:, line_items:, currency:)` signs the intent, cart and payment mandates for a quote and pays; on `payment_setup_required` it calls `payment_setup` and pays once more.
-- `Customer#account`, `#role` and `#claims` read its credential; `#signs_back_in`, `#with_a_fresh_credential`, `#redeems(link_code)`, `#asks_to_be_linked`, `#polls` and `#collects` are the sign-in and linking ceremonies.
+- `Customer#sets_up_payment` and `#requests_verification` run the engine's `payment_setup` and `request_kyc`, and `#hears_verification_passed` waits for the outcome of the check it asked for last; `#pays(checkout_jwt)` signs the two closed AP2 mandates for the checkout an action answered, unchanged, and pays; on `payment_setup_required` it calls `payment_setup` and pays once more.
+- `Customer#account`, `#role` and `#claims` read its credential; `#signs_back_in` and `#with_a_fresh_credential` ask the token endpoint for a new token; `#redeems(link_code)`, `#asks_to_be_linked`, `#polls` and `#collects` are the linking ceremonies.
 - `Customer#listens_for`, `#follows(*topics, subject:, since:)` and `#hears(topic, about:, on:, **data)` read the event stream, holding each heard payload to the schema the origin publishes for its topic.
 - `a_person(email:, password:)` signs a person in on the operator's site through `kiosk-user-idp-devise`'s `DeviseSession`: `links(customer)`, `link_code`, `approves(user_code)`, `unlinks(customer)`, `visits(path)`.
 

data/lib/kiosk/test_helpers/assistant/events.rb

@@ -6,6 +6,7 @@ require 'openssl'
 require 'socket'
 require 'uri'
 require 'websocket/driver'
+require 'kiosk/test_helpers/dpop'
 
 module Kiosk
   module TestHelpers
@@ -35,14 +36,15 @@ module Kiosk
 
         attr_reader :url
 
-        def initialize(base_url:, token:, path: '/kiosk/events', timeout: 10)
-          uri  = URI(base_url)
-          tls  = uri.scheme == 'https'
-          @url = "#{tls ? 'wss' : 'ws'}://#{uri.host}:#{uri.port}#{path}"
-          @io  = open_socket(uri.hostname, uri.port, tls)
+        # `key` signs the DPoP proof of the upgrade; its `htu` is the events URL
+        # with the HTTP scheme, because the upgrade is an HTTP request there.
+        def initialize(base_url:, token:, key:, path: '/kiosk/events', timeout: 10)
+          http = URI.join(base_url, path)
+          @url = http.to_s.sub(/\Ahttp/, 'ws')
+          @io  = open_socket(http.hostname, http.port, http.scheme == 'https')
           @frames = []
           @closed = false
-          @driver = start_driver(token)
+          @driver = start_driver(Dpop.headers(token, key, method: 'GET', url: http.to_s))
           pump(timeout) { @frames.any? { it['type'] == 'welcome' } } || raise(Error, "#{@url} did not welcome the connection")
         end
 
@@ -98,9 +100,9 @@ module Kiosk
           ssl
         end
 
-        def start_driver(token)
+        def start_driver(headers)
           driver = WebSocket::Driver.client(self)
-          driver.set_header('Authorization', "Bearer #{token}")
+          headers.each { |name, value| driver.set_header(name, value) }
           driver.on(:message) { @frames << JSON.parse(it.data) }
           driver.on(:close)   { @closed = true }
           driver.on(:error)   { @closed = true }

data/lib/kiosk/test_helpers/assistant.rb

@@ -6,12 +6,14 @@ require 'securerandom'
 require 'uri'
 require 'jwt'
 require 'kiosk/test_helpers/wire'
+require 'kiosk/test_helpers/mandate'
 require 'kiosk/test_helpers/assistant/events'
 
 module Kiosk
   module TestHelpers
-    # An assistant on the wire: registers, then queries, runs and pays as the
-    # principal it registered, paying every proof-of-work toll it is asked for.
+    # An assistant on the wire: registers its key as an OAuth client, then
+    # queries, runs and pays as the principal its token names, paying every
+    # proof-of-work toll it is asked for.
     #
     #   assistant = Kiosk::TestHelpers::Assistant.new(base_url: live_url)
     #   rider     = assistant.register!
@@ -19,8 +21,12 @@ module Kiosk
     class Assistant
       class RegistrationError < StandardError; end
 
-      # The account an assistant registered, and the key that signs its mandates.
-      Principal = Data.define(:agent_id, :user_id, :token, :rsa_key)
+      # The account an assistant acts for, its client_id (the agent_id), and
+      # the key that signs its client assertions, DPoP proofs and mandates.
+      Principal = Data.define(:agent_id, :user_id, :token, :key)
+
+      ASSERTION_TYPE = 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer'
+      DEVICE_CODE = 'urn:ietf:params:oauth:grant-type:device_code'
 
       attr_reader :wire
 
@@ -30,119 +36,133 @@ module Kiosk
 
       def base_url = wire.base_url
 
-      # `pow:` is `:solve`, `:skip` (send no proof) or a String sent verbatim as
-      # the proof; `wire_role:` puts a `role` the engine must ignore into the body.
-      def register_raw(pow: :solve, wire_role: nil)
-        register(pow:, wire_role:).first
+      # Registers `key` (RFC 7591). `pow:` is `:solve`, `:skip` (send no proof)
+      # or a String sent verbatim as the proof; `wire_role:` puts a `role` the
+      # engine must ignore into the body.
+      def register_raw(pow: :solve, wire_role: nil, key: Dpop.generate_key)
+        body = { jwks: jwks(key), token_endpoint_auth_method: 'private_key_jwt' }
+        body[:role] = wire_role if wire_role
+        case pow
+        when :solve then wire.post('/kiosk/oauth/register', body)
+        when :skip then unpaid.post('/kiosk/oauth/register', body)
+        else unpaid.post('/kiosk/oauth/register', body, 'Kiosk-PoW' => pow)
+        end
+      end
+
+      # A new key, registered: the principal has a client_id and no token yet.
+      def register_client!(pow: :solve)
+        key  = Dpop.generate_key
+        resp = register_raw(pow:, key:)
+        raise RegistrationError, "registration expected 201, got #{resp.status}: #{resp.body.inspect}" unless resp.status == 201
+
+        Principal.new(agent_id: resp.body.fetch('client_id'), user_id: nil, token: nil, key: key)
       end
 
-      def register!(pow: :solve)
-        response, key = register(pow:)
-        raise RegistrationError, "register! expected 201, got #{response.status}: #{response.body.inspect}" unless response.status == 201
+      # A new key, registered, holding its first token.
+      def register!(pow: :solve) = signed_in(register_client!(pow:))
 
-        Principal.new(agent_id: response.body.fetch('agent_id'), user_id: response.body.fetch('user_id'),
-                      token: response.body.fetch('access_token'), rsa_key: key)
+      # The principal holding a new token from the client_credentials grant.
+      def signed_in(principal)
+        response = token(principal)
+        raise RegistrationError, "token request expected 200, got #{response.status}: #{response.body.inspect}" unless response.status == 200
+
+        access_token = response.body.fetch('access_token')
+        principal.with(token: access_token, user_id: JWT.decode(access_token, nil, false).first['sub'])
       end
 
-      # The unauthenticated request that opens the account-binding ceremony (RFC 8628 §3.1).
-      def device_authorization(client_id:, public_key:, **extra)
-        wire.post_form('/kiosk/oauth/device_authorization',
-                       { 'client_id' => client_id, 'public_key' => public_key }.merge(extra.transform_keys(&:to_s)))
+      # Asks the token endpoint for a token of the principal's client (RFC 6749 §4.4).
+      def token(principal) = token_request(principal, 'grant_type' => 'client_credentials')
+
+      # Polls for the token a person grants on the operator's site (RFC 8628 §3.4).
+      def device_token(device_code, principal)
+        token_request(principal, 'grant_type' => DEVICE_CODE, 'device_code' => device_code)
+      end
+
+      # Opens the account-binding ceremony (RFC 8628 §3.1), with whatever else the caller sends.
+      def device_authorization(principal, **extra)
+        wire.post_form('/kiosk/oauth/device_authorization', assertion_params(principal).merge(extra.transform_keys(&:to_s)))
       end
 
       def kyc(principal, attestation_jws:)
-        wire.post('/kiosk/agents/kyc', { kyc_jws: attestation_jws }, wire.bearer(principal.token))
+        wire.post('/kiosk/agents/kyc', { kyc_jws: attestation_jws }, credential(principal))
       end
 
       # `pay_tolls: false` answers a proof-of-work toll instead of paying it.
       def query(principal, name:, headers: {}, pay_tolls: true, **params)
-        (pay_tolls ? wire : unpaid).get("/kiosk/#{name}", params, wire.bearer(principal.token).merge(headers))
+        (pay_tolls ? wire : unpaid).get("/kiosk/#{name}", params, credential(principal).merge(headers))
       end
 
       def run(principal, name:, headers: {}, **args)
-        wire.post("/kiosk/#{name}", args, wire.bearer(principal.token).merge(headers))
+        wire.post("/kiosk/#{name}", args, credential(principal).merge(headers))
       end
 
-      # The intent and cart mandates for a quote of `total` cents, for #pay.
-      def mandates(principal, total:, scope:, line_items:, currency: 'eur')
-        now    = Time.now.to_i
-        common = { user_id: principal.user_id, agent_id: principal.agent_id, iss: base_url, currency:, iat: now, exp: now + 600 }
-        intent = common.merge(id: SecureRandom.uuid, scope:, cap_amount_cents: total)
-        { intent:, cart: common.merge(id: SecureRandom.uuid, intent_mandate_id: intent[:id], total_amount_cents: total, line_items:) }
-      end
-
-      def pay(principal, intent:, cart:, payment_method: 'pm_demo')
-        payment = payment_mandate(principal, cart:, payment_method:)
-        pay_raw(principal, intent_jws: sign_mandate(principal, intent), cart_jws: sign_mandate(principal, cart),
-                           payment_jws: sign_mandate(principal, payment))
+      # Signs the two closed AP2 mandates for `checkout_jwt`, unchanged, and pays.
+      def pay(principal, checkout_jwt, instrument: 'on_file')
+        pay_raw(principal, **Mandate.pay(principal.key, checkout_jwt, instrument:))
       end
 
       # On a 402 `payment_setup_required` it calls `payment_setup`, as the hint
       # asks, and sends the same mandates once more. Against stripe-mock the
       # Customer that `payment_setup` maps already lists a card, so that answer settles.
-      def pay_raw(principal, intent_jws:, cart_jws:, payment_jws:)
-        body   = { intent_mandate_jws: intent_jws, cart_mandate_jws: cart_jws, payment_mandate_jws: payment_jws }
-        answer = wire.post('/kiosk/pay', body, wire.bearer(principal.token))
+      def pay_raw(principal, checkout:, payment:)
+        body   = { checkout_mandate: checkout, payment_mandate: payment }
+        answer = wire.post('/kiosk/pay', body, credential(principal))
         return answer unless setup_required?(answer)
 
         run(principal, name: 'payment_setup')
-        wire.post('/kiosk/pay', body, wire.bearer(principal.token))
+        wire.post('/kiosk/pay', body, credential(principal))
       end
 
-      def payment_mandate(principal, cart:, payment_method: 'pm_demo')
-        cart = cart.transform_keys(&:to_sym)
-        now  = Time.now.to_i
-        { id: SecureRandom.uuid, cart_mandate_id: cart[:id], user_id: principal.user_id, agent_id: principal.agent_id,
-          iss: cart[:iss], payment_method:, amount_cents: cart[:total_amount_cents], currency: cart[:currency],
-          exp: now + 600, iat: now }
+      # Puts a new key on the principal's client (spec Section 5.7): the old
+      # key's assertion names the new key, and the new key signs its own. The
+      # answer's Principal holds the new key and a token bound to it.
+      def rotate(principal, new_key: Dpop.generate_key)
+        body = { client_assertion_type: ASSERTION_TYPE,
+                 client_assertion: client_assertion(principal, new_key: Dpop.thumbprint(new_key)),
+                 new_client_assertion: client_assertion(principal.with(key: new_key)), jwks: jwks(new_key) }
+        response = wire.post('/kiosk/auth/rotate', body)
+        return response unless response.status == 200
+
+        signed_in(principal.with(key: new_key))
       end
 
-      def sign_mandate(principal, payload) = JWT.encode(payload, principal.rsa_key, 'RS256')
-
-      # Signs in again with the key it holds.
-      def login(key) = wire.post('/kiosk/auth/login', possession(key))
-
-      # Redeems a link code a person minted on the operator's site.
-      def claim(code, key) = wire.post('/kiosk/auth/claim', { code: }.merge(possession(key)))
-
-      # Polls for the credential a person grants on the operator's site (RFC 8628 §3.4).
-      def device_token(device_code, key)
-        wire.post_form('/kiosk/oauth/token', 'grant_type' => 'urn:ietf:params:oauth:grant-type:device_code',
-                                             'device_code' => device_code, 'signed' => proof_of_possession(key))
-      end
+      # Redeems a link code a person minted on the operator's site; answers 204.
+      def claim(code, principal) = wire.post('/kiosk/auth/claim', { code:, **assertion_params(principal) })
 
-      # A proof that the assistant holds `key`, over a fresh challenge and bound to this origin.
-      def proof_of_possession(key)
-        _, challenge = wire.get_json('/kiosk/auth/challenge', public_key: key.public_key.to_pem)
-        JWT.encode({ aud: base_url, nonce: challenge['challenge'], jti: SecureRandom.uuid, iat: Time.now.to_i }, key, 'RS256')
+      # A client assertion (RFC 7523 §3) that the principal's key signs for this
+      # origin. `claims` adds or replaces members, such as the `new_key` of a rotation.
+      def client_assertion(principal, **claims)
+        payload = { iss: principal.agent_id, sub: principal.agent_id, aud: base_url, exp: Time.now.to_i + 60,
+                    jti: SecureRandom.uuid, **claims }
+        JWT.encode(payload, principal.key, Dpop.algorithm(principal.key))
       end
 
       # What the origin publishes about itself at `/kiosk/schema`.
       def schema = @schema ||= wire.get_json('/kiosk/schema').last
 
-      def events(principal) = Events.new(base_url:, token: principal.token).tap { (@connections ||= []) << it }
+      def events(principal) = Events.new(base_url:, token: principal.token, key: principal.key).tap { (@connections ||= []) << it }
 
       # Closes every event connection it opened.
       def disconnect = @connections&.each(&:close)
 
       private
 
-      def register(pow:, wire_role: nil)
-        key  = OpenSSL::PKey::RSA.generate(2048)
-        body = possession(key)
-        body[:role] = wire_role if wire_role
-        response = case pow
-                   when :solve then wire.post('/kiosk/auth/register', body)
-                   when :skip then unpaid.post('/kiosk/auth/register', body)
-                   else unpaid.post('/kiosk/auth/register', body, 'Kiosk-PoW' => pow)
-                   end
-        [response, key]
+      def jwks(key) = { keys: [Dpop.jwk(key)] }
+
+      def assertion_params(principal)
+        { 'client_assertion_type' => ASSERTION_TYPE, 'client_assertion' => client_assertion(principal) }
       end
 
-      def possession(key) = { public_key: key.public_key.to_pem, signed: proof_of_possession(key) }
+      # A token request carries a DPoP proof of the registered key, with no token yet.
+      def token_request(principal, form)
+        wire.post_form('/kiosk/oauth/token', form.merge(assertion_params(principal)), wire.dpop(nil, principal.key))
+      end
 
       def unpaid = Wire.new(base_url:)
 
+      # The principal's token and key, which the wire signs a DPoP proof with.
+      def credential(principal) = wire.dpop(principal.token, principal.key)
+
       def setup_required?(answer)
         answer.status == 402 && answer.body.is_a?(Hash) && answer.body['code'] == 'payment_setup_required'
       end

data/lib/kiosk/test_helpers/customer.rb

@@ -40,10 +40,8 @@ module Kiosk
     class Customer
       attr_reader :principal
 
-      # An assistant holding a key and no account at its origin yet.
-      def self.newcomer(assistant)
-        new(assistant, Assistant::Principal.new(agent_id: nil, user_id: nil, token: nil, rsa_key: OpenSSL::PKey::RSA.generate(2048)))
-      end
+      # An assistant that registered its key here and acts for no person yet.
+      def self.newcomer(assistant) = new(assistant, assistant.register_client!)
 
       def initialize(assistant, principal)
         @assistant = assistant
@@ -60,15 +58,8 @@ module Kiosk
 
       def does(action, headers: {}, **args) = Answer.new(@assistant.run(principal, name: action.to_s, headers:, **args))
 
-      # Signs intent, cart and payment mandates for `total` cents and pays.
-      def pays(total:, scope:, line_items:, currency: 'eur')
-        Answer.new(@assistant.pay(principal, **@assistant.mandates(principal, total:, scope:, line_items:, currency:)))
-      end
-
-      # Signs the `cart` an action answered with, unchanged, and pays.
-      def pays_cart(cart, scope:, currency: cart['currency'])
-        pays(total: cart['total_amount_cents'], scope:, line_items: cart['line_items'], currency:)
-      end
+      # Signs the checkout and payment mandates for the `checkout_jwt` an action answered, and pays.
+      def pays(checkout_jwt) = Answer.new(@assistant.pay(principal, checkout_jwt))
 
       # The answer says whether a card is on file, or carries the page where the person saves one.
       def sets_up_payment = does(:payment_setup)
@@ -92,21 +83,25 @@ module Kiosk
       def account = claims['sub']
       def role = claims['role']
 
-      def signs_back_in = Answer.new(@assistant.login(principal.rsa_key))
+      # Asks the token endpoint for a new token with the key it holds.
+      def signs_back_in = Answer.new(@assistant.token(principal))
 
-      # This assistant holding the credential a fresh sign-in issues.
+      # This assistant holding the credential a fresh token request issues.
       def with_a_fresh_credential = holding(signs_back_in)
 
       # Redeems the link code a person handed over; the assistant then acts for that person.
-      def redeems(link_code) = holding(Answer.new(@assistant.claim(link_code, principal.rsa_key)))
+      def redeems(link_code)
+        claimed = Answer.new(@assistant.claim(link_code, principal))
+        raise "#{origin} did not redeem #{link_code}: #{claimed}" unless claimed.ok?
 
-      # Asks to be linked to a person's account; the answer carries the code the person approves.
-      def asks_to_be_linked(client_id: 'kiosk-story')
-        Answer.new(@assistant.device_authorization(client_id:, public_key: principal.rsa_key.public_key.to_pem))
+        with_a_fresh_credential
       end
 
+      # Asks to be linked to a person's account; the answer carries the code the person approves.
+      def asks_to_be_linked = Answer.new(@assistant.device_authorization(principal))
+
       # Asks once whether the person has approved `request`.
-      def polls(request) = Answer.new(@assistant.device_token(request['device_code'], principal.rsa_key))
+      def polls(request) = Answer.new(@assistant.device_token(request['device_code'], principal))
 
       # This assistant holding the credential the person granted through `request`.
       def collects(request) = holding(polls(request))

data/lib/kiosk/test_helpers/dpop.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'digest'
+require 'jwt'
+require 'openssl'
+require 'securerandom'
+require 'uri'
+require 'kiosk/server/eddsa'
+
+module Kiosk
+  module TestHelpers
+    # The two headers of a call that carries an access token (RFC 9449): the
+    # token as `Authorization: DPoP`, and a proof that the token's key signs
+    # for this method and URL. A token request has no token yet: it sends
+    # only the proof, with no `ath`.
+    #
+    #   Dpop.headers(token, key, method: 'GET', url: 'https://shop.example/kiosk/catalog')
+    #   Dpop.headers(nil, key, method: 'POST', url: 'https://shop.example/kiosk/oauth/token')
+    module Dpop
+      module_function
+
+      # A new assistant key: Ed25519, or P-256 for `ES256`.
+      def generate_key(algorithm = 'EdDSA')
+        algorithm == 'ES256' ? OpenSSL::PKey::EC.generate('prime256v1') : OpenSSL::PKey.generate_key('ED25519')
+      end
+
+      # The JOSE algorithm the key signs with: EdDSA or ES256.
+      def algorithm(key) = Kiosk::Server::Jwk.algorithm(key)
+
+      def headers(token, key, method:, url:, iat: Time.now.to_i)
+        proof = { 'DPoP' => proof(token, key, method:, url:, iat:) }
+        token ? { 'Authorization' => "DPoP #{token}", **proof } : proof
+      end
+
+      # The same two headers as Rack env entries.
+      def env(token, key, method:, url:, iat: Time.now.to_i)
+        { 'HTTP_AUTHORIZATION' => "DPoP #{token}", 'HTTP_DPOP' => proof(token, key, method:, url:, iat:) }
+      end
+
+      # `url` loses its query and fragment: `htu` names the resource, not the arguments.
+      def proof(token, key, method:, url:, iat: Time.now.to_i)
+        uri = URI(url.to_s)
+        htu = "#{uri.scheme}://#{uri.host}#{":#{uri.port}" unless uri.port == uri.default_port}#{uri.path}"
+        payload = { jti: SecureRandom.uuid, htm: method.to_s.upcase, htu: htu, iat: iat }
+        payload[:ath] = ath(token) if token
+        JWT.encode(payload, key, algorithm(key), { typ: 'dpop+jwt', jwk: jwk(key) })
+      end
+
+      def ath(token) = Base64.urlsafe_encode64(Digest::SHA256.digest(token.to_s), padding: false)
+
+      # The RFC 7638 thumbprint of the key: a token's `cnf.jkt`, a rotation's `new_key`.
+      def thumbprint(key) = Kiosk::Server::Jwk.thumbprint(key)
+
+      # The public JWK (RFC 7517) of the key: a proof's `jwk`, a registration's `jwks` member.
+      def jwk(key) = Kiosk::Server::Jwk.public_members(key)
+    end
+  end
+end

data/lib/kiosk/test_helpers/in_process_wire.rb

@@ -9,6 +9,7 @@ require 'rack/mock'
 require 'uri'
 require 'kiosk/server'
 require 'kiosk/test_helpers/wire'
+require 'kiosk/test_helpers/dpop'
 
 module Kiosk
   module TestHelpers
@@ -24,10 +25,10 @@ module Kiosk
 
       # The verb's answer, or the wire error its refusal names.
       def call(name, kind:, params:, identity:)
-        token      = token_for(identity) if identity
-        response   = request(name, kind, params, token)
+        credential = credential_for(identity) if identity
+        response   = request(name, kind, params, credential)
         challenges = toll_challenges(response)
-        response   = request(name, kind, params, token, Wire.solve(challenges)) if challenges
+        response   = request(name, kind, params, credential, Wire.solve(challenges)) if challenges
         answer(response)
       end
 
@@ -35,27 +36,40 @@ module Kiosk
 
       def app = @app || ::Rails.application
 
-      def request(name, kind, params, token, proofs = nil)
-        env = credentials(token, proofs)
+      def request(name, kind, params, credential, proofs = nil)
+        query = kind.to_sym == :query
         url = "#{Kiosk.current_issuer.to_s.chomp('/')}#{Kiosk.configuration.mount_path}/#{name}"
-        return Rack::MockRequest.new(app).get(query_url(url, params), env) if kind.to_sym == :query
+        env = credentials(credential, query ? 'GET' : 'POST', url, proofs)
+        return Rack::MockRequest.new(app).get(query_url(url, params), env) if query
 
         Rack::MockRequest.new(app).post(url, env.merge(input: JSON.generate(params), 'CONTENT_TYPE' => 'application/json'))
       end
 
-      def credentials(token, proofs)
-        { 'HTTP_AUTHORIZATION' => ("Bearer #{token}" if token),
-          'HTTP_KIOSK_POW' => (JSON.generate(proofs) if proofs) }.compact
+      # The access token with a DPoP proof its key signs for this request.
+      def credentials(credential, method, url, proofs)
+        env = credential ? Dpop.env(credential.token, credential.key, method:, url:) : {}
+        env['HTTP_KIOSK_POW'] = JSON.generate(proofs) if proofs
+        env
       end
 
       def query_url(url, params) = params.empty? ? url : "#{url}?#{URI.encode_www_form(params)}"
 
-      # The token of an assistant linked to the principal for this call.
-      def token_for(identity)
-        Kiosk::Server::AccountBinding.bind!(
-          public_key_pem: OpenSSL::PKey::RSA.generate(2048).public_key.to_pem,
-          user_id: identity.user_id, requested_role: identity.role
-        ).fetch(:access_token)
+      # The token and key of an assistant registered and linked to the principal for this call.
+      def credential_for(identity)
+        key    = Dpop.generate_key
+        client = Kiosk::Server::AccountBinding.bind!(agent_id: register(key).id, user_id: identity.user_id,
+                                                     requested_role: identity.role)
+        token  = Kiosk::Server::AgentIdentityProviders::DefaultAgentIdp.new.issue(agent_id: client.id, role: client.role)
+        Wire::DpopCredential.new(token:, key:)
+      end
+
+      # Registers the key as a client, and pays the registration toll if the origin asks for one.
+      def register(key)
+        metadata = { 'jwks' => { 'keys' => [Kiosk::Server::AssistantKey.to_jwk(key)] } }
+        Kiosk::Server::ClientRegistration.call(metadata)
+      rescue Kiosk::Server::Errors::PowRequired => e
+        header = JSON.generate(Wire.solve(JSON.parse(JSON.generate(e.challenges))))
+        Kiosk::Server::ClientRegistration.call(metadata, pow: Kiosk::Server::PowGate.proofs_from_header(header))
       end
 
       def toll_challenges(response)

data/lib/kiosk/test_helpers/kyc.rb

@@ -24,7 +24,7 @@ module Kiosk
       class Provider < Kiosk::KycProviders::Base
         Check = Data.define(:subject, :audience, :nonce, :callback_url)
 
-        def self.key = @key ||= OpenSSL::PKey::RSA.generate(2048)
+        def self.key = @key ||= OpenSSL::PKey.generate_key('ED25519')
 
         def initialize
           super
@@ -47,7 +47,7 @@ module Kiosk
         def attest(subject, audience, attributes)
           now = Time.now.to_i
           JWT.encode({ sub: subject.to_s, level: 'verified', iss: ISSUER, aud: audience.to_s, attributes:,
-                       iat: now, exp: now + 3600 }, self.class.key, 'RS256')
+                       iat: now, exp: now + 3600 }, self.class.key, 'EdDSA')
         end
       end
 
@@ -87,7 +87,7 @@ module Kiosk
         @kyc_provider = Provider.new
         config.kyc_provider   = @kyc_provider
         config.kyc_issuer     = ISSUER
-        config.kyc_public_key = Provider.key.public_key
+        config.kyc_public_key = Provider.key
       end
 
       def restore_kyc_provider

data/lib/kiosk/test_helpers/live_server.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
-require 'puma'
 require 'socket'
+begin
+  require 'puma'
+rescue LoadError
+  raise LoadError, "Kiosk::TestHelpers::LiveServer serves the app with Puma. Add gem 'puma' to the Gemfile."
+end
 require 'kiosk/test_helpers/assistant'
 
 module Kiosk

data/lib/kiosk/test_helpers/mandate.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'digest'
+require 'json'
+require 'jwt'
+require 'securerandom'
+require 'kiosk/test_helpers/dpop'
+
+module Kiosk
+  module TestHelpers
+    # The two closed AP2 v0.2 mandates an assistant signs to pay an operator's
+    # checkout, as compact SD-JWTs: what an assistant following the skill sends.
+    module Mandate
+      module_function
+
+      # @param checkout_jwt [String] the checkout an action answered, unchanged
+      # @return [Hash] `checkout:` and `payment:`, each a compact SD-JWT
+      def pay(key, checkout_jwt, instrument: 'on_file', lifetime: 600)
+        checkout = JWT.decode(checkout_jwt, nil, false).first
+        checkout_hash = digest(checkout_jwt)
+        now = Time.now.to_i
+        times = { iat: now, exp: now + lifetime }
+        { checkout: sign(key, { vct: 'mandate.checkout.1', checkout_jwt:, checkout_hash:, **times }),
+          payment: sign(key, { vct: 'mandate.payment.1', transaction_id: checkout_hash, payee: checkout['merchant'],
+                               payment_amount: { amount: checkout['total_amount_cents'], currency: checkout['currency'] },
+                               payment_instrument: { id: instrument, type: 'card' }, **times }) }
+      end
+
+      # A closed mandate: an SD-JWT whose one disclosure is `content`.
+      def sign(key, content)
+        disclosure = b64(JSON.generate([b64(SecureRandom.random_bytes(16)), content]))
+        jwt = JWT.encode({ _sd_alg: 'sha-256', delegate_payload: [{ '...' => digest(disclosure) }] }, key, Dpop.algorithm(key),
+                         { typ: 'dc+sd-jwt' })
+        "#{jwt}~#{disclosure}~"
+      end
+
+      # The disclosed mandate of `sd_jwt`, unverified.
+      def content(sd_jwt) = JSON.parse(Base64.urlsafe_decode64(sd_jwt.split('~')[1])).last
+
+      def digest(text) = b64(Digest::SHA256.digest(text))
+
+      def b64(bytes) = Base64.urlsafe_encode64(bytes, padding: false)
+    end
+  end
+end

data/lib/kiosk/test_helpers/pow_solver.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kiosk
+  module TestHelpers
+    # The solver for a proof-of-work challenge. kiosk-pow-equihash ships the one
+    # solver here, and the host's bundle brings that gem.
+    module PowSolver
+      def self.for(challenge)
+        alg = challenge['alg']
+        raise ArgumentError, "The origin asks for a #{alg.inspect} proof of work. Wire solves only Equihash." unless alg == 'equihash'
+
+        require 'kiosk/pow/equihash/solver'
+        Kiosk::Pow::Equihash
+      rescue LoadError
+        raise LoadError, "Wire solves Equihash tolls with kiosk-pow-equihash. Add gem 'kiosk-pow-equihash' to the Gemfile."
+      end
+    end
+  end
+end

data/lib/kiosk/test_helpers/story.rb

@@ -18,7 +18,7 @@ module Kiosk
       # A newly registered assistant, as `as` (a demo's own Customer subclass).
       def a_customer(as: Customer) = as.new(assistant, register)
 
-      # An assistant holding a key and no account here yet.
+      # An assistant that registered its key here and acts for no person yet.
       def a_newcomer(as: Customer) = as.newcomer(assistant)
 
       # Someone with an account on the operator's site, signed in there.

data/lib/kiosk/test_helpers/version.rb

@@ -2,6 +2,6 @@
 
 module Kiosk
   module TestHelpers
-    VERSION = '0.5.20'
+    VERSION = '0.6.1'
   end
 end

data/lib/kiosk/test_helpers/wire.rb

@@ -3,7 +3,8 @@
 require 'json'
 require 'net/http'
 require 'uri'
-require 'kiosk/pow/equihash/solver'
+require 'kiosk/test_helpers/dpop'
+require 'kiosk/test_helpers/pow_solver'
 
 module Kiosk
   module TestHelpers
@@ -11,7 +12,7 @@ module Kiosk
     # `pay_tolls: true` it solves a proof-of-work toll and sends the request once more.
     #
     #   wire = Kiosk::TestHelpers::Wire.new(base_url: "http://127.0.0.1:3006")
-    #   status, problem = wire.post_json("/kiosk/edit_listing", { listing_id: "junk" }, Wire.bearer(token))
+    #   status, problem = wire.post_json("/kiosk/edit_listing", { listing_id: "junk" }, wire.dpop(token, key))
     class Wire
       # One answer: a body that is not JSON reads as `{}`, an unreachable origin as status 0.
       Response = Data.define(:status, :headers, :body, :raw_body, :proofs) do
@@ -42,10 +43,15 @@ module Kiosk
         http
       end
 
-      def self.bearer(token) = { 'Authorization' => "Bearer #{token}" }
+      # An access token and the key it is bound to. As a header value, the wire
+      # sends it as `Authorization: DPoP <token>` with a proof for that request;
+      # with no token, as the proof alone (a token request).
+      DpopCredential = Data.define(:token, :key)
+
+      def self.dpop(token, key) = { 'Authorization' => DpopCredential.new(token:, key:) }
 
       # A solved proof of work for each challenge, as the `Kiosk-PoW` header carries them.
-      def self.solve(challenges) = challenges.map { { challenge: it, nonce: Kiosk::Pow::Equihash.solve(it) } }
+      def self.solve(challenges) = challenges.map { { challenge: it, nonce: PowSolver.for(it).solve(it) } }
 
       attr_reader :base_url
 
@@ -56,7 +62,7 @@ module Kiosk
         @read_timeout = read_timeout
       end
 
-      def bearer(token) = self.class.bearer(token)
+      def dpop(token, key) = self.class.dpop(token, key)
 
       def post_json(path, body = {}, headers = {}) = post(path, body, headers).then { [it.status, it.body] }
 
@@ -97,10 +103,8 @@ module Kiosk
         challenges if challenges.is_a?(Array) && challenges.any?
       end
 
-      def deliver(klass, uri, body, headers)
-        request = klass.new(uri, body.nil? ? headers : { 'Content-Type' => 'application/json' }.merge(headers))
-        request.body = JSON.generate(body) unless body.nil?
-        yield request if block_given?
+      def deliver(klass, uri, body, headers, &)
+        request = build(klass, uri, body, headers, &)
         begin
           answer = self.class.http_for(uri, open_timeout: @open_timeout, read_timeout: @read_timeout).request(request)
         rescue StandardError => e
@@ -109,6 +113,25 @@ module Kiosk
         response(answer)
       end
 
+      def build(klass, uri, body, headers)
+        headers = { 'Content-Type' => 'application/json' }.merge(headers) unless body.nil?
+        request = klass.new(uri, signed(headers, klass::METHOD, uri))
+        request.body = JSON.generate(body) unless body.nil?
+        yield request if block_given?
+        request
+      end
+
+      # Each delivery signs its own DPoP proof, so a retry never reuses one.
+      def signed(headers, method, uri)
+        headers.each_with_object({}) do |(name, value), out|
+          if value.is_a?(DpopCredential)
+            out.merge!(Dpop.headers(value.token, value.key, method:, url: uri.to_s))
+          else
+            out[name] = value
+          end
+        end
+      end
+
       def response(answer)
         raw_body = answer.body.to_s
         body = begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kiosk-test-support
 version: !ruby/object:Gem::Version
-  version: 0.5.20
+  version: 0.6.1
 platform: ruby
 authors:
 - Phil Pirozhkov
@@ -35,7 +35,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.10'
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
@@ -45,7 +45,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.10'
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
@@ -55,42 +55,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
-  name: kiosk-pow-equihash
+  name: kiosk-server
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
-  name: puma
+  name: kiosk-user-idp-devise
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: websocket-driver
   requirement: !ruby/object:Gem::Requirement
@@ -130,10 +130,12 @@ description: |
   mandates and listens on the event stream. `Kyc` stands in for the
   operator's KYC provider, and `StripeMock` fronts a local stripe-mock.
 
-  No Postgres, no Rails, no test-framework dependency.
-  `InProcessExecutor` and `Conformance::InProcessOrigin` run against
-  the host's kiosk-server and are required explicitly; this gem does
-  not depend on kiosk-server.
+  `InProcessExecutor`, `InProcessWire` and `Conformance::InProcessOrigin`
+  run against kiosk-server, and `Person` signs in through
+  kiosk-user-idp-devise; both are dependencies. The host's bundle brings
+  the rest: the Minitest and RSpec adapters use the test framework the
+  host runs, `LiveServer` serves the app with Puma, and `Wire` solves
+  Equihash tolls with kiosk-pow-equihash.
 email:
 - hello@fili.pp.ru
 executables: []
@@ -163,14 +165,17 @@ files:
 - lib/kiosk/test_helpers/conformance/verb.rb
 - lib/kiosk/test_helpers/customer.rb
 - lib/kiosk/test_helpers/descriptor_examples.rb
+- lib/kiosk/test_helpers/dpop.rb
 - lib/kiosk/test_helpers/errors.rb
 - lib/kiosk/test_helpers/in_process_executor.rb
 - lib/kiosk/test_helpers/in_process_wire.rb
 - lib/kiosk/test_helpers/journey.rb
 - lib/kiosk/test_helpers/kyc.rb
 - lib/kiosk/test_helpers/live_server.rb
+- lib/kiosk/test_helpers/mandate.rb
 - lib/kiosk/test_helpers/null_executor.rb
 - lib/kiosk/test_helpers/person.rb
+- lib/kiosk/test_helpers/pow_solver.rb
 - lib/kiosk/test_helpers/small_equihash.rb
 - lib/kiosk/test_helpers/story.rb
 - lib/kiosk/test_helpers/stripe_mock.rb