ruby_everywhere 0.2.0 → 0.4.0

data/lib/everywhere/auth_token.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "openssl"
+
+module Everywhere
+  # The sealed envelopes the native auth flow passes around: the marker cookie
+  # that says "this browser session is completing a sign-in for the app", and
+  # the handoff token that carries the resulting cookie jar back into the app's
+  # web view.
+  #
+  # Self-contained (encrypt-then-authenticate, expiry inside the payload) rather
+  # than a server-side store: the flow crosses processes — and in a load-balanced
+  # deploy, hosts — between the auth browser and the web view, and a shared
+  # store would be one more thing to configure. AES-256-GCM with the purpose as
+  # associated data, so a marker can never be replayed as a handoff token.
+  module AuthToken
+    CIPHER = "aes-256-gcm"
+    NONCE_BYTES = 12
+    TAG_BYTES = 16
+
+    class MissingSecret < StandardError; end
+
+    class << self
+      # The secret the tokens are keyed from. Set explicitly, or left to be
+      # discovered: the Rails app's secret_key_base, else SECRET_KEY_BASE /
+      # EVERYWHERE_AUTH_SECRET from the environment (Sinatra/Hanami).
+      attr_writer :secret
+
+      def secret
+        @secret ||= discover_secret or raise(MissingSecret, <<~MESSAGE)
+          Native sign-in needs a secret to seal its handoff tokens. Rails apps use
+          secret_key_base automatically; elsewhere set SECRET_KEY_BASE (or
+          EVERYWHERE_AUTH_SECRET) in the environment, or assign
+          Everywhere::AuthToken.secret at boot.
+        MESSAGE
+      end
+
+      def encrypt(payload, purpose:, ttl:)
+        sealed = JSON.generate(payload.merge("exp" => now + ttl))
+        cipher = OpenSSL::Cipher.new(CIPHER).encrypt
+        cipher.key = key
+        nonce = cipher.random_iv
+        cipher.auth_data = purpose.to_s
+        ciphertext = cipher.update(sealed) + cipher.final
+        Base64.urlsafe_encode64(nonce + cipher.auth_tag + ciphertext, padding: false)
+      end
+
+      # The payload, or nil for anything we can't fully vouch for: tampered,
+      # wrong purpose, expired, or (when `once`) already spent. Never raises on
+      # bad input — every one of these arrives from outside.
+      def decrypt(token, purpose:, once: false)
+        raw = Base64.urlsafe_decode64(token.to_s)
+        return nil if raw.bytesize <= NONCE_BYTES + TAG_BYTES
+
+        decipher = OpenSSL::Cipher.new(CIPHER).decrypt
+        decipher.key = key
+        decipher.iv = raw.byteslice(0, NONCE_BYTES)
+        decipher.auth_tag = raw.byteslice(NONCE_BYTES, TAG_BYTES)
+        decipher.auth_data = purpose.to_s
+
+        payload = JSON.parse(decipher.update(raw.byteslice(NONCE_BYTES + TAG_BYTES..)) + decipher.final)
+        return nil unless payload.is_a?(Hash) && payload["exp"].to_i > now
+        return nil if once && !claim(token, payload["exp"].to_i)
+
+        payload
+      rescue ArgumentError, OpenSSL::Cipher::CipherError, JSON::ParserError
+        nil
+      end
+
+      # Test hook — a new secret means a new key.
+      def reset!
+        @secret = nil
+        @key = nil
+        @spent = nil
+      end
+
+      private
+
+      def key
+        @key ||= OpenSSL::Digest::SHA256.digest("ruby_everywhere/auth-token\0#{secret}")
+      end
+
+      def discover_secret
+        if defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+          base = ::Rails.application.secret_key_base
+          return base if base && !base.empty?
+        end
+        %w[SECRET_KEY_BASE EVERYWHERE_AUTH_SECRET].each do |name|
+          value = ENV[name]
+          return value if value && !value.empty?
+        end
+        nil
+      end
+
+      # Spend a token, returning false if it was already spent. In-process only:
+      # across workers the ceiling is the token's own (seconds-long) expiry,
+      # which is the guarantee that actually matters — the token never leaves
+      # the device, and a replay would only re-establish the session its owner
+      # already holds.
+      def claim(token, expires_at)
+        digest = OpenSSL::Digest::SHA256.hexdigest(token.to_s)
+        spent_mutex.synchronize do
+          spent.reject! { |_, exp| exp <= now }
+          return false if spent.key?(digest)
+
+          spent[digest] = expires_at
+          true
+        end
+      end
+
+      def spent = @spent ||= {}
+      def spent_mutex = @spent_mutex ||= Mutex.new
+      def now = Time.now.to_i
+    end
+  end
+end