samagotchi 0.110.0 → 0.111.0

data/lib/samagotchi/web/push/client.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+require_relative "crypto"
+
+module Samagotchi
+  module Web
+    module Push
+      # One push to one device: the payload encrypted for its keys
+      # (Crypto.encrypt), POSTed to its endpoint with chi web's VAPID header,
+      # and the push service's answer as a Result. No retry (P1). See
+      # docs/internals/web-push.md.
+      class Client
+        OPEN_TIMEOUT = 5
+        READ_TIMEOUT = 10
+
+        # +status+ :ok (201/200/202), :gone (404/410: the device dropped
+        # it), :bad_jwt (403 BadJwtToken: the push service refused chi's
+        # VAPID token) or :failed; +code+ the HTTP status (nil when none
+        # came), +error+ a short word for a failure, +ms+ the call's time.
+        Result = Data.define(:status, :code, :ms, :error) do
+          def initialize(error: nil, **) = super
+          def ok? = status == :ok
+        end
+
+        # Net::HTTP over TLS, the timeouts above; a transport takes the URI
+        # and the request and returns the response (specs inject one).
+        TLS = lambda do |uri, request|
+          Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: OPEN_TIMEOUT, read_timeout: READ_TIMEOUT) do |http|
+            http.request(request)
+          end
+        end
+
+        # What a failed connection says in the log: never its message (it
+        # may carry the endpoint).
+        NETWORK_ERRORS = [SocketError, SystemCallError, IOError, OpenSSL::SSL::SSLError, Timeout::Error,
+                          Net::HTTPBadResponse, Net::ProtocolError].freeze
+
+        # @param key [OpenSSL::PKey::EC] chi web's VAPID key (Store#vapid_key)
+        # @param contact [String] the VAPID sub (Crypto.valid_sub?)
+        # @param transport [#call] (uri, request) → Net::HTTPResponse
+        # @param clock [#call] the Time now (the JWT's exp)
+        # @param monotonic [#call] seconds, for +ms+
+        def initialize(key:, contact:, transport: TLS, clock: -> { Time.now },
+                       monotonic: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+          @key = key
+          @contact = contact
+          @transport = transport
+          @clock = clock
+          @monotonic = monotonic
+        end
+
+        # Never the key.
+        def inspect = "#<#{self.class.name} #{@contact}>"
+        alias to_s inspect
+
+        # @param sub [Store::Sub]
+        # @param payload [Hash] the JSON the service worker reads
+        # @param ttl [Integer] seconds the push service keeps it for an
+        #   offline device
+        # @param urgency ["high", "normal"]
+        # @return [Result]
+        def deliver(sub, payload, ttl:, urgency:)
+          started = @monotonic.call
+          response = @transport.call(URI(sub.endpoint), request(sub, payload, ttl: ttl, urgency: urgency))
+          result_for(response, ms(started))
+        rescue *NETWORK_ERRORS => e
+          Result.new(status: :failed, code: nil, ms: ms(started), error: e.is_a?(Timeout::Error) ? "timeout" : e.class.name)
+        end
+
+        private
+
+        def request(sub, payload, ttl:, urgency:)
+          body = Crypto.encrypt(JSON.generate(payload), p256dh: sub.p256dh_bytes, auth: sub.auth_bytes)
+          Net::HTTP::Post.new(URI(sub.endpoint)).tap do |req|
+            req["Content-Encoding"] = "aes128gcm"
+            req["Content-Type"] = "application/octet-stream"
+            req["TTL"] = ttl.to_i.to_s
+            req["Urgency"] = urgency
+            req["Authorization"] = Crypto.vapid_authorization(sub.endpoint, key: @key, sub: @contact, now: @clock.call)
+            req.body = body
+          end
+        end
+
+        def result_for(response, elapsed)
+          code = response.code.to_i
+          status = case code
+                   when 200, 201, 202 then :ok
+                   when 404, 410 then :gone
+                   when 403 then response.body.to_s.include?("BadJwtToken") ? :bad_jwt : :failed
+                   else :failed
+                   end
+          Result.new(status: status, code: code, ms: elapsed, error: status == :failed ? code.to_s : nil)
+        end
+
+        def ms(started) = ((@monotonic.call - started) * 1000).round
+      end
+    end
+  end
+end

data/lib/samagotchi/web/push/crypto.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+require "uri"
+
+module Samagotchi
+  module Web
+    module Push
+      # Web Push's two pieces of crypto, on OpenSSL alone (no gem): the
+      # message body a push service carries to the device (RFC 8291's
+      # aes128gcm, RFC 8188: one record, no padding), and the VAPID
+      # Authorization header that says the push comes from chi web's key
+      # (RFC 8292: an ES256 JWT for the endpoint's origin). The RFC 8291
+      # Appendix A vector pins #encrypt byte for byte
+      # (spec/web/push/crypto_spec.rb). See docs/internals/web-push.md.
+      module Crypto
+        module_function
+
+        GROUP = "prime256v1"
+        # RFC 8188's record size: one record holds a push message (< 4 KB).
+        RECORD_SIZE = 4096
+        # A VAPID token lives this long (RFC 8292 allows up to 24 h).
+        JWT_TTL = 12 * 3600
+
+        def b64u(bytes) = [bytes].pack("m0").tr("+/", "-_").delete("=")
+
+        # base64url with or without its padding; ArgumentError when it
+        # isn't base64url.
+        def unb64u(text)
+          text = text.to_s
+          raise ArgumentError, "not base64url" unless text.match?(/\A[A-Za-z0-9_-]*={0,2}\z/)
+
+          text = text.delete_suffix("=").delete_suffix("=")
+          raise ArgumentError, "not base64url" if text.length % 4 == 1
+
+          (text.tr("-_", "+/") + ("=" * ((4 - (text.length % 4)) % 4))).unpack1("m0")
+        end
+
+        # A new P-256 key (chi web's VAPID key; a message's sender key).
+        def generate_key = OpenSSL::PKey::EC.generate(GROUP)
+
+        # The 65-byte uncompressed point of +key+'s public half.
+        def raw_public(key) = key.public_key.to_octet_string(:uncompressed)
+
+        # What the page hands pushManager.subscribe as applicationServerKey.
+        def public_key_b64(key) = b64u(raw_public(key))
+
+        # A P-256 public key from its 65-byte uncompressed point (OpenSSL 3
+        # keys are immutable: built through an SPKI DER).
+        def ec_public(raw)
+          spki = OpenSSL::ASN1::Sequence([
+            OpenSSL::ASN1::Sequence([OpenSSL::ASN1::ObjectId("id-ecPublicKey"),
+                                     OpenSSL::ASN1::ObjectId(GROUP)]),
+            OpenSSL::ASN1::BitString(raw)
+          ])
+          OpenSSL::PKey::EC.new(spki.to_der)
+        end
+
+        # A P-256 key pair from its 32-byte private scalar and its public
+        # point (RFC 8291's fixed sender key, a spec's receiver).
+        def ec_private(priv, pub)
+          der = OpenSSL::ASN1::Sequence([
+            OpenSSL::ASN1::Integer(1),
+            OpenSSL::ASN1::OctetString(priv),
+            OpenSSL::ASN1::ObjectId(GROUP, 0, :EXPLICIT),
+            OpenSSL::ASN1::BitString(pub, 1, :EXPLICIT)
+          ])
+          OpenSSL::PKey::EC.new(der.to_der)
+        end
+
+        def hkdf(salt, ikm, info, length) = OpenSSL::KDF.hkdf(ikm, salt: salt, info: info, length: length, hash: "SHA256")
+
+        # RFC 8291 §3.4: +plaintext+ for the device whose subscription keys
+        # are +p256dh+ (its 65-byte public point) and +auth+ (16 bytes), as
+        # one aes128gcm record (RFC 8188 §2: salt, rs, idlen, keyid, then the
+        # record with its 0x02 delimiter and no padding). +salt+ and
+        # +sender_key+ are fresh per message; the RFC vector fixes them.
+        # @return [String] the request body (binary)
+        def encrypt(plaintext, p256dh:, auth:, salt: OpenSSL::Random.random_bytes(16), sender_key: generate_key)
+          sender_public = raw_public(sender_key)
+          shared = sender_key.derive(ec_public(p256dh))
+          ikm = hkdf(auth, shared, "WebPush: info\0".b + p256dh.b + sender_public, 32)
+          cek = hkdf(salt, ikm, "Content-Encoding: aes128gcm\0".b, 16)
+          nonce = hkdf(salt, ikm, "Content-Encoding: nonce\0".b, 12)
+          cipher = OpenSSL::Cipher.new("aes-128-gcm").encrypt
+          cipher.key = cek
+          cipher.iv = nonce
+          record = cipher.update("#{plaintext.b}\x02".b) + cipher.final + cipher.auth_tag
+          salt.b + [RECORD_SIZE].pack("N") + [sender_public.bytesize].pack("C") + sender_public + record
+        end
+
+        # RFC 8292: the Authorization header for a push to +endpoint+, signed
+        # with +key+ (chi web's VAPID key): aud = the endpoint's origin, exp
+        # = +now+ + JWT_TTL, sub = +sub+ (a contact URL: valid_sub?).
+        # @param now [Time]
+        def vapid_authorization(endpoint, key:, sub:, now: Time.now)
+          claims = { aud: origin_of(endpoint), exp: now.to_i + JWT_TTL, sub: sub }
+          input = "#{b64u(JSON.generate({ typ: "JWT", alg: "ES256" }))}.#{b64u(JSON.generate(claims))}"
+          # ES256 wants r‖s, 32 bytes each; OpenSSL signs DER.
+          r, s = OpenSSL::ASN1.decode(key.sign("SHA256", input)).value.map { |int| int.value.to_s(2).rjust(32, "\0") }
+          "vapid t=#{input}.#{b64u(r + s)}, k=#{public_key_b64(key)}"
+        end
+
+        # scheme://host[:port] of a URL, the port only when it isn't the
+        # scheme's default.
+        def origin_of(url)
+          uri = URI(url)
+          "#{uri.scheme}://#{uri.host}#{":#{uri.port}" unless uri.port == uri.default_port}"
+        end
+
+        # A VAPID sub Apple takes: a mailto: with an @, or an https URL with
+        # a host. A bare "chi@localhost" gets 403 BadJwtToken (the spike).
+        def valid_sub?(sub)
+          text = sub.to_s
+          return text.match?(/\Amailto:[^@\s]+@[^@\s]+\z/) if text.start_with?("mailto:")
+
+          uri = URI.parse(text)
+          uri.scheme == "https" && !uri.host.to_s.empty?
+        rescue URI::InvalidURIError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/samagotchi/web/push/notifier.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "attention"
+require_relative "../../log"
+
+module Samagotchi
+  module Web
+    module Push
+      # chi web's one sender of pushes: a SessionHub subscriber that keeps
+      # the summaries the page's trackAttention keeps (seeded by the
+      # subscribe's snapshot, so what was open before never pushes), turns
+      # each new approval or question (Attention.for) into a show, and
+      # hands it to its own sender thread through a Queue; one answered
+      # anywhere (Attention.closed_keys) only cancels its show's hold.
+      #
+      # Every push it sends shows a notification: WebKit removes a
+      # subscription after a few pushes that show none (its silent-push
+      # quota), so there is no close push. A show carries +open+, the keys
+      # still open, and the badge, both from the sink's summaries
+      # (Attention.open_keys): the service worker closes the answered ones
+      # when it shows the new one, and the page when it opens.
+      #
+      # #call is the hub's sink: it runs under the hub's Monitor, on the
+      # tick thread and on chi web's request threads (SessionHub#touch), so
+      # it only enqueues; a push is a 0.5 s https call, made on the sender
+      # thread. There a show waits its hold (HOLD, or the event's own) and
+      # is pushed only while still open, to every device subscribed on this
+      # run's public origin. See docs/internals/web-push.md.
+      class Notifier
+        HOLD = 3.0
+        # Waiting kinds: kept 12 h for an offline phone, delivered at once.
+        SHOW_TTL = 12 * 3600
+        # A show carries +open+ only while its JSON stays this small: one
+        # aes128gcm record leaves 3993 bytes of plaintext under Web Push's
+        # 4096 (86 header, 1 delimiter, 16 tag). Longer, it goes without
+        # (and the worker cleans up nothing).
+        OPEN_LIMIT = 3000
+        STOP_JOIN = 2.0
+
+        Show = Data.define(:attention, :title, :body, :at)
+        Close = Data.define(:keys)
+
+        # @param store [Store] the devices (and the key the client signs with)
+        # @param client [#deliver] Client
+        # @param origin [String] this run's public origin: only the
+        #   subscriptions made on it are sent to
+        # @param now [#call] monotonic seconds (specs move it)
+        def initialize(store:, client:, origin:, hold: HOLD, now: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+          @store = store
+          @client = client
+          @origin = origin
+          @hold = hold
+          @now = now
+          @queue = Queue.new
+          # The sink's side (under @mutex): the last summary per session.
+          @mutex = Mutex.new
+          @by_id = {}
+          @seeded = false
+          @early = []
+          # The sender's side (its thread only, or #pump in a spec).
+          @pending = {} # key → Show waiting its hold
+          @refused = false
+          @thread = nil
+          @handle = nil
+        end
+
+        # Subscribes to +hub+ (its snapshot is the seed) and starts the
+        # sender thread. Call it after a hub.scan, or the snapshot is empty
+        # and the first scan's events push every open approval.
+        # @param sender [Boolean] false: no thread, a spec drives #pump
+        def start(hub, sender: true)
+          @handle, summaries = hub.subscribe(self, snapshot: true)
+          seed(summaries)
+          @thread = Thread.new { run } if sender
+          self
+        end
+
+        # Unsubscribes and ends the sender thread; holds still waiting are
+        # dropped, a push in flight may finish (joined with a timeout).
+        def stop
+          @handle&.unsubscribe
+          @handle = nil
+          @queue << :stop
+          @thread&.join(STOP_JOIN)
+          @thread = nil
+          nil
+        end
+
+        # The hub's sink (SessionHub::Event): never blocks.
+        def call(event)
+          @mutex.synchronize do
+            next @early << event unless @seeded
+
+            notice(event)
+          end
+        end
+
+        # The seed: the summaries as the subscribe saw them. Events that came
+        # before it (newer than the snapshot) are applied after it.
+        def seed(summaries)
+          @mutex.synchronize do
+            summaries.each { |summary| @by_id[summary[:id]] = summary if summary[:id] }
+            @seeded = true
+            @early.each { |event| notice(event) }
+            @early.clear
+          end
+        end
+
+        # What is queued, handled now, then the shows whose hold is up
+        # pushed; the sender thread's step (specs call it with no thread).
+        def pump
+          loop do
+            message = @queue.pop(true)
+            return if message == :stop
+
+            handle(message)
+          rescue ThreadError
+            break
+          end
+          flush
+        end
+
+        private
+
+        def notice(event)
+          case event.type
+          when "session"
+            summary = event.data[:session]
+            return unless summary.is_a?(Hash) && summary[:id]
+
+            prev = @by_id[summary[:id]]
+            @by_id[summary[:id]] = summary
+            keys = Attention.closed_keys(prev, summary)
+            @queue << Close.new(keys: keys) unless keys.empty?
+            attention = Attention.for(prev, summary)
+            enqueue_show(attention, summary) if attention
+          when "session_gone"
+            prev = @by_id.delete(event.data[:id])
+            keys = Attention.closed_keys(prev, nil)
+            @queue << Close.new(keys: keys) unless keys.empty?
+          end
+        end
+
+        def enqueue_show(attention, summary)
+          title, body = Attention.text(summary, attention.reason)
+          @queue << Show.new(attention: attention, title: title, body: body, at: @now.call)
+        end
+
+        def run
+          loop do
+            due = @pending.values.map { |show| due_at(show) }.min
+            wait = due && [due - @now.call, 0].max
+            message = @queue.pop(timeout: wait)
+            break if message == :stop
+
+            handle(message) if message
+            flush
+          rescue StandardError => e
+            Log.exception(:web, "push_sender_failed", e)
+          end
+        end
+
+        def handle(message)
+          case message
+          when Show then @pending[message.attention.key] = message
+          # Answered anywhere: a show still in its hold is dropped. Nothing
+          # is pushed (a push that shows nothing counts against the quota).
+          when Close then message.keys.each { |key| @pending.delete(key) }
+          end
+        end
+
+        def due_at(show) = show.at + (show.attention.hold || @hold)
+
+        def flush
+          now = @now.call
+          due = @pending.values.select { |show| due_at(show) <= now }
+          return if due.empty?
+
+          due.each { |show| @pending.delete(show.attention.key) }
+          open = @mutex.synchronize { Attention.open_keys(@by_id) }
+          due.each do |show|
+            key = show.attention.key
+            next unless open.include?(key)
+
+            deliver(show_payload(show, open), kind: show.attention.reason)
+          end
+        end
+
+        def show_payload(show, open)
+          payload = { v: 1, kind: "show", tag: show.attention.key, title: show.title, body: show.body,
+                      url: "/#/s/#{show.attention.session_id}", badge: open.size }
+          with_open = payload.merge(open: open)
+          JSON.generate(with_open).bytesize <= OPEN_LIMIT ? with_open : payload
+        end
+
+        # @param kind [String] the reason, for the log line
+        # @return [Boolean] whether any device took it
+        def deliver(payload, kind:)
+          return false if @refused
+
+          @store.for_origin(@origin).map do |sub|
+            result = @client.deliver(sub, payload, ttl: SHOW_TTL, urgency: "high")
+            record(sub, result, kind)
+            result.ok?
+          end.any?
+        end
+
+        def record(sub, result, kind)
+          fields = { device: sub.id, code: result.code, ms: result.ms, kind: kind }
+          case result.status
+          when :ok
+            Log.info(:web, "push_sent", **fields)
+            @store.mark(sub.id, ok: true)
+          when :gone
+            Log.info(:web, "push_gone", **fields)
+            @store.remove(sub.id)
+          when :bad_jwt
+            @refused = true
+            Log.warn(:web, "push_bad_jwt", echo: "[chi web] the push service refused chi's VAPID token: check " \
+                                                 "web.push.contact (no pushes until chi web restarts)", **fields)
+          else
+            Log.warn(:web, "push_failed", error: result.error, **fields)
+            @store.mark(sub.id, error: result.error)
+          end
+        end
+      end
+    end
+  end
+end