clowk 0.6.1 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1aad1a920ab61f2ff4a89d52ceede9e30edf63a92f2fa5cb60e99eb3032f5a39
-  data.tar.gz: a701bfc46f4c2ae7c2bc57d731ab9a9ff4dde4dc454fc0634e8b1d6a08603b80
+  metadata.gz: 33d1a92eb50a3515f9c312ccd3ba71dbc9bedfd11935797f70497aa076dbb55b
+  data.tar.gz: 38aa689ff1303246487acaad73cf02c34955bafa9a44bc44544b6ce289e758a3
 SHA512:
-  metadata.gz: bd7bb4bc6f95eb20c9cdabbb5f7e1dd1664f5d2566b895bd0e7466c46821ee7262b25bea0ced1aaf21e4ae8fa858ada4b28161d5517d7241f8ec31607ef5cae8
-  data.tar.gz: e0d6c2d830d16cc85c003c114240e0b2270f7de8288d85f1eb4b5d564613d8681c1d484a37fcf36a76908f44f6e9d3b9579d2890d4e3abf4cc84917375c2d03e
+  metadata.gz: b334fda452268ee1ae58a897ddbd07dfe6c0f715f4a2693ddadffbeb882af3d906bf4e76ce655160eb5c204c2de6d175c596ecc182b4261ef9edfc21c31f6b51
+  data.tar.gz: 4516f8fdc4dd79291fa895c2a203d7920b3d44ee69bf89f1a8c3f11877f65e36d1e8dd70b67b5a99c49462e15c07d33f25b42d85466fd87f44e2a3244745248e

data/README.md

@@ -227,6 +227,48 @@ What changes in that mode:
   session, keyed by a digest of the token. Without it, `enforce_active_session`
   would cost a round trip to Clowk on every authenticated request.
 
+### Keeping a session honest
+
+A valid token proves who signed in, not that the session still stands —
+revocation lives server-side. `config.enforce_active_session = true` checks it,
+and `config.session_status_ttl` decides how often that costs a round trip.
+
+Some actions cannot take a cached answer. Rotating a secret, deleting an
+account, removing a member: a status from fourteen minutes ago is a hole. Name
+those actions and they get a live one:
+
+```ruby
+class ApiKeysController < ApplicationController
+  clowk_require_fresh_session only: [:create, :update, :destroy]
+end
+```
+
+It takes the same options as `before_action`. Everything not named keeps the
+cached check, so an app pays for the round trip on the few actions it cannot
+undo and nowhere else. `clowk_enforce_fresh_session!` is the same thing as a
+method, and `clowk_session_active?(force: true)` returns the answer instead of
+enforcing it.
+
+Two settings decide what happens when Clowk itself cannot be reached:
+
+```ruby
+config.fail_open_on_broker_error = true   # default
+config.max_session_age = 12.hours         # default nil
+```
+
+Failing open leaves the session standing and checks again on the next request —
+a blip on the way to a single droplet must not sign everyone out. Only network
+failures count; anything else still raises, because a bug must not read as "the
+session is probably fine".
+
+`max_session_age` is the other half of that, and failing open is not safe
+without it: a local ceiling the broker plays no part in, so a permanently
+unreachable Clowk cannot keep a session alive forever. Past it the session ends
+with no round trip at all.
+
+Both ends — the broker said inactive, the ceiling passed — go through
+`config.on_session_expired` when you set one.
+
 ### Token verification
 
 Tokens signed with `RS256` are verified against Clowk's public key set, fetched

data/lib/clowk/authenticable.rb

@@ -7,6 +7,11 @@ module Clowk
   module Authenticable
     extend ActiveSupport::Concern
 
+    # What a liveness check can raise once Clowk::Http's retries are spent, plus
+    # connection-refused, which retries never cover. Anything else is a bug and
+    # must not be swallowed into "the session is probably fine".
+    BROKER_UNAVAILABLE = [SystemCallError, Timeout::Error, IOError, SocketError, EOFError].freeze
+
     def self.install_dynamic_methods(base)
       scope = Clowk.config.prefix_by.to_s
       current_method = :"current_#{scope}"
@@ -14,6 +19,7 @@ module Clowk
       signed_in_method = :"#{scope}_signed_in?"
 
       enforce_session_method = :"#{scope}_enforce_session!"
+      enforce_fresh_method = :"#{scope}_enforce_fresh_session!"
       sign_out_method = :"#{scope}_sign_out!"
 
       base.class_eval do
@@ -41,6 +47,12 @@ module Clowk
           end
         end
 
+        unless enforce_fresh_method == :clowk_enforce_fresh_session!
+          define_method(enforce_fresh_method) do
+            clowk_enforce_fresh_session!
+          end
+        end
+
         unless sign_out_method == :clowk_sign_out!
           define_method(sign_out_method) do
             clowk_sign_out!
@@ -55,6 +67,22 @@ module Clowk
       Clowk::Authenticable.install_dynamic_methods(self)
     end
 
+    class_methods do
+      # Demand a live answer from Clowk before these actions, whatever a cached
+      # status says.
+      #
+      #   class ApiKeysController < ApplicationController
+      #     clowk_require_fresh_session only: [:create, :update, :destroy]
+      #   end
+      #
+      # Takes the same options as before_action. Everything NOT listed keeps the
+      # cached check, which is the point: an app pays for a round trip on the few
+      # actions that cannot be undone, and nowhere else.
+      def clowk_require_fresh_session(**options)
+        before_action(**options) { clowk_enforce_fresh_session! }
+      end
+    end
+
     # Per-request credentials — for apps whose keys are not a boot constant:
     # an operator pastes a publishable key into a settings screen, or one
     # process serves several tenants.
@@ -90,27 +118,53 @@ module Clowk
       clowk_current_resource.present?
     end
 
-    def clowk_session_status
-      @clowk_session_status ||= resolve_session_status
-    end
+    # @param force [Boolean] ignore any cached status and ask Clowk now
+    def clowk_session_status(force: false)
+      return @clowk_session_status if defined?(@clowk_session_status) && !force
 
-    def clowk_session_active?
-      clowk_session_status&.dig(:status) == "active"
+      @clowk_session_status = resolve_session_status(force: force)
     end
 
-    def clowk_enforce_session!
-      return if clowk_session_active?
+    # @param force [Boolean] see {#clowk_session_status}
+    def clowk_session_active?(force: false)
+      status = clowk_session_status(force: force)
 
-      session_info = clowk_session_status
-      callback = Clowk.config.on_session_expired
+      # "Could not ask" rather than "not active": a blip on the way to a single
+      # droplet must not sign everyone out. max_session_age is the bound on how
+      # long that can carry a session Clowk would have refused.
+      return true if @clowk_session_check_unavailable && Clowk.config.fail_open_on_broker_error
 
-      if callback.respond_to?(:call)
-        callback.call(self, session_info)
+      status&.dig(:status) == "active"
+    end
 
-        return
-      end
+    # Ends the session unless Clowk says, right now, that it still stands.
+    #
+    # For the handful of actions where a cached "active" is not good enough:
+    # rotating a secret, deleting an account, removing a member. Everything else
+    # should take the cached check — this is a round trip, on purpose.
+    #
+    #   clowk_require_fresh_session only: [:destroy, :rotate_secret]
+    #
+    # Before 0.7 the only way to get this was `session_status_ttl = 0`, which
+    # bought freshness here by paying a round trip on every page instead.
+    def clowk_enforce_fresh_session!
+      clowk_enforce_session!(force: true)
+    end
 
-      clowk_handle_expired_session(session_info)
+    # @param force [Boolean] see {#clowk_session_status}
+    def clowk_enforce_session!(force: false)
+      # Nothing to enforce against a request that carries no session. Reached
+      # through clowk_authenticate! this is already true, but the method is also
+      # a before_action in its own right — and called that way with no session it
+      # read "not active" and ended one that never existed. On a page that skips
+      # the identity gate on purpose (an invite link, a public page that shows
+      # more when signed in) that threw away whatever the redirect was carrying.
+      return unless clowk_signed_in?
+
+      return clowk_expire_session!(nil) if clowk_session_beyond_max_age?
+      return if clowk_session_active?(force: force)
+
+      clowk_expire_session!(clowk_session_status)
     end
 
     def clowk_authenticate!
@@ -158,6 +212,37 @@ module Clowk
       end
     end
 
+    # One route out of a session that must end, whatever ended it — the broker
+    # said inactive, or the local ceiling passed. Apps hook it with
+    # config.on_session_expired; the default answers 401 or redirects.
+    def clowk_expire_session!(session_info)
+      callback = Clowk.config.on_session_expired
+
+      if callback.respond_to?(:call)
+        callback.call(self, session_info)
+
+        return
+      end
+
+      clowk_handle_expired_session(session_info)
+    end
+
+    # A ceiling Clowk plays no part in. Without it, failing open on an
+    # unreachable broker would mean a session that never ends.
+    #
+    # signed_in_at is stamped once, when the session is established:
+    # clowk_current_resource prefers the stored payload, so persist_clowk_session
+    # does not run again while the session stands.
+    def clowk_session_beyond_max_age?
+      max = Clowk.config.max_session_age.to_i
+
+      return false unless max.positive?
+
+      started = (stored_session&.dig("signed_in_at") || stored_session&.dig(:signed_in_at)).to_i
+
+      started.positive? && (Time.now.to_i - started) > max
+    end
+
     def clowk_handle_expired_session(_session_info)
       if clowk_api_request?
         render json: {error: "Session expired or inactive"}, status: :unauthorized
@@ -253,8 +338,9 @@ module Clowk
       })
     end
 
-    def resolve_session_status
-      cached = clowk_read_cached_session_status
+    def resolve_session_status(force: false)
+      @clowk_session_check_unavailable = false
+      cached = force ? nil : clowk_read_cached_session_status
 
       return cached if cached
 
@@ -273,6 +359,14 @@ module Clowk
 
       status
     rescue Clowk::InvalidTokenError
+      nil
+    rescue *BROKER_UNAVAILABLE => e
+      # Never cached: "we could not ask" is not an answer worth keeping, and the
+      # next request should try again rather than inherit this one's bad luck.
+      @clowk_session_check_unavailable = true
+
+      Clowk.config.http_logger&.warn("[Clowk] session check unavailable: #{e.class}: #{e.message}")
+
       nil
     end
 

data/lib/clowk/configuration.rb

@@ -25,6 +25,8 @@ module Clowk
     attr_accessor :enforce_active_session
     attr_accessor :on_session_expired
     attr_accessor :session_status_ttl
+    attr_accessor :max_session_age
+    attr_accessor :fail_open_on_broker_error
     attr_writer :session_status_cache
 
     def initialize
@@ -52,6 +54,16 @@ module Clowk
       # which silently turns every later enforcement call into a no-op. Set 0 to
       # check on every call.
       @session_status_ttl = 300
+
+      # A local ceiling the broker plays no part in, so a permanently
+      # unreachable Clowk cannot keep a session alive forever — the other half
+      # of failing open. nil leaves the broker as the only authority.
+      @max_session_age = nil
+
+      # A network blip must not sign everyone out. When the liveness check
+      # cannot be made at all, the session is left standing and checked again on
+      # the next request; max_session_age is what bounds that.
+      @fail_open_on_broker_error = true
     end
 
     # Where API-only apps cache session status, since they have no Rails session

data/lib/clowk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clowk
-  VERSION = "0.6.1"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clowk
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.1
 platform: ruby
 authors:
 - Clowk