Add a token prefix column, generate the token_prefix and the token_digest, removing the plaintext token from use.

app/models/concerns/token_prefixable.rb

@@ -0,0 +1,53 @@
+module TokenPrefixable
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Compute HMAC prefix from plaintext token
+    # Returns first 8 chars of Base64url-encoded HMAC
+    # Does NOT reveal anything about the token
+    def compute_token_prefix(plaintext_token)
+      return nil if plaintext_token.blank?
+
+      hmac = OpenSSL::HMAC.digest('SHA256', TokenHmac::KEY, plaintext_token)
+      Base64.urlsafe_encode64(hmac)[0..7]
+    end
+
+    # Find token using HMAC prefix lookup (fast, indexed)
+    def find_by_token(plaintext_token)
+      return nil if plaintext_token.blank?
+
+      prefix = compute_token_prefix(plaintext_token)
+
+      # Fast indexed lookup by HMAC prefix
+      where(token_prefix: prefix).find_each do |token|
+        return token if token.token_matches?(plaintext_token)
+      end
+
+      nil
+    end
+  end
+
+  # Check if a plaintext token matches the hashed token
+  def token_matches?(plaintext_token)
+    return false if plaintext_token.blank? || token_digest.blank?
+
+    BCrypt::Password.new(token_digest) == plaintext_token
+  rescue BCrypt::Errors::InvalidHash
+    false
+  end
+
+  # Generate new token with HMAC prefix
+  # Sets both virtual attribute (for returning to client) and digest (for storage)
+  def generate_token_with_prefix
+    plaintext = SecureRandom.urlsafe_base64(48)
+    self.token_prefix = self.class.compute_token_prefix(plaintext)
+    self.token_digest = BCrypt::Password.create(plaintext)
+
+    # Set the virtual attribute - different models use different names
+    if respond_to?(:plaintext_token=)
+      self.plaintext_token = plaintext  # OidcAccessToken
+    elsif respond_to?(:token=)
+      self.token = plaintext  # OidcRefreshToken
+    end
+  end
+end

app/models/oidc_access_token.rb

@@ -1,12 +1,15 @@
 class OidcAccessToken < ApplicationRecord
+  include TokenPrefixable
+
   belongs_to :application
   belongs_to :user
   has_many :oidc_refresh_tokens, dependent: :destroy
 
-  before_validation :generate_token, on: :create
+  before_validation :generate_token_with_prefix, on: :create
   before_validation :set_expiry, on: :create
 
-  validates :token, uniqueness: true, presence: true
+  validates :token_digest, presence: true
+  validates :token_prefix, presence: true
 
   scope :valid, -> { where("expires_at > ?", Time.current).where(revoked_at: nil) }
   scope :expired, -> { where("expires_at <= ?", Time.current) }
@@ -33,50 +36,11 @@ class OidcAccessToken < ApplicationRecord
     oidc_refresh_tokens.each(&:revoke!)
   end
 
-  # Check if a plaintext token matches the hashed token
-  def token_matches?(plaintext_token)
-    return false if plaintext_token.blank?
-
-    # Use BCrypt to compare if token_digest exists
-    if token_digest.present?
-      BCrypt::Password.new(token_digest) == plaintext_token
-    # Fall back to direct comparison for backward compatibility
-    elsif token.present?
-      token == plaintext_token
-    else
-      false
-    end
-  end
-
-  # Find by token (validates and checks if revoked)
-  def self.find_by_token(plaintext_token)
-    return nil if plaintext_token.blank?
-
-    # Find all non-revoked, non-expired tokens
-    valid.find_each do |access_token|
-      # Use BCrypt to compare (if token_digest exists) or direct comparison
-      if access_token.token_digest.present?
-        return access_token if BCrypt::Password.new(access_token.token_digest) == plaintext_token
-      elsif access_token.token == plaintext_token
-        return access_token
-      end
-    end
-    nil
-  end
+  # find_by_token, token_matches?, and generate_token_with_prefix
+  # are now provided by TokenPrefixable concern
 
   private
 
-  def generate_token
-    return if token.present?
-
-    # Generate opaque access token
-    plaintext = SecureRandom.urlsafe_base64(48)
-    self.plaintext_token = plaintext  # Store temporarily for returning to client
-    self.token_digest = BCrypt::Password.create(plaintext)
-    # Keep token column for backward compatibility during migration
-    self.token = plaintext
-  end
-
   def set_expiry
     self.expires_at ||= application.access_token_expiry
   end

app/models/oidc_refresh_token.rb

@@ -1,10 +1,12 @@
 class OidcRefreshToken < ApplicationRecord
+  include TokenPrefixable
+
   belongs_to :application
   belongs_to :user
   belongs_to :oidc_access_token
   has_many :oidc_access_tokens, foreign_key: :oidc_access_token_id, dependent: :nullify
 
-  before_validation :generate_token, on: :create
+  before_validation :generate_token_with_prefix, on: :create
   before_validation :set_expiry, on: :create
   before_validation :set_token_family_id, on: :create
 
@@ -43,37 +45,11 @@ class OidcRefreshToken < ApplicationRecord
     OidcRefreshToken.in_family(token_family_id).update_all(revoked_at: Time.current)
   end
 
-  # Verify a plaintext token against the stored digest
-  def self.find_by_token(plaintext_token)
-    return nil if plaintext_token.blank?
-
-    # Try to find tokens that could match (we can't search by hash directly)
-    # This is less efficient but necessary with BCrypt
-    # In production, you might want to add a token prefix or other optimization
-    all.find do |refresh_token|
-      refresh_token.token_matches?(plaintext_token)
-    end
-  end
-
-  def token_matches?(plaintext_token)
-    return false if plaintext_token.blank? || token_digest.blank?
-
-    BCrypt::Password.new(token_digest) == plaintext_token
-  rescue BCrypt::Errors::InvalidHash
-    false
-  end
+  # find_by_token, token_matches?, and generate_token_with_prefix
+  # are now provided by TokenPrefixable concern
 
   private
 
-  def generate_token
-    # Generate a secure random token
-    plaintext = SecureRandom.urlsafe_base64(48)
-    self.token = plaintext  # Store temporarily for returning to client
-
-    # Hash it with BCrypt for storage
-    self.token_digest = BCrypt::Password.create(plaintext)
-  end
-
   def set_expiry
     # Use application's configured refresh token TTL
     self.expires_at ||= application.refresh_token_expiry