module Rodauth

    # File lib/rodauth/features/email_auth.rb
243 def _account_from_email_auth_key(token)
244   account_from_key(token, account_open_status_value){|id| get_email_auth_key(id)}
245 end

    # File lib/rodauth/features/base.rb
656 def _account_from_login(login)
657   ds = db[accounts_table].where(login_column=>login)
658   ds = ds.select(*account_select) if account_select
659   ds = ds.where(account_status_column=>[account_unverified_status_value, account_open_status_value]) unless skip_status_checks?
660   ds.first
661 end

    # File lib/rodauth/features/jwt_refresh.rb
111 def _account_from_refresh_token(token)
112   id, token_id, key = _account_refresh_token_split(token)
113 
114   unless key &&
115          (id == session_value.to_s) &&
116          (actual = get_active_refresh_token(id, token_id)) &&
117          timing_safe_eql?(key, convert_token_key(actual)) &&
118          jwt_refresh_token_match?(key)
119     return
120   end
121 
122   ds = account_ds(id)
123   ds = ds.where(account_session_status_filter) unless skip_status_checks?
124   ds.first
125 end

    # File lib/rodauth/features/reset_password.rb
255 def _account_from_reset_password_key(token)
256   account_from_key(token, account_open_status_value){|id| get_password_reset_key(id)}
257 end

    # File lib/rodauth/features/base.rb
663 def _account_from_session
664   ds = account_ds(session_value)
665   ds = ds.where(account_session_status_filter) unless skip_status_checks?
666   ds.first
667 end

    # File lib/rodauth/features/lockout.rb
299 def _account_from_unlock_key(token)
300   account_from_key(token){|id| account_lockouts_ds(id).get(account_lockouts_key_column)}
301 end

    # File lib/rodauth/features/verify_account.rb
309 def _account_from_verify_account_key(token)
310   account_from_key(token, account_unverified_status_value){|id| get_verify_account_key(id)}
311 end

    # File lib/rodauth/features/verify_login_change.rb
212 def _account_from_verify_login_change_key(token)
213   account_from_key(token) do |id|
214     @verify_login_change_new_login, key = get_verify_login_change_login_and_key(id)
215     key
216   end
217 end

    # File lib/rodauth/features/jwt_refresh.rb
127 def _account_refresh_token_split(token)
128   id, token = split_token(token)
129   return unless id && token
130 
131   token_id, key = split_token(token)
132   return unless token_id && key
133 
134   [id, token_id, key]
135 end

    # File lib/rodauth/features/base.rb
492 def _around_rodauth
493   yield
494 end

    # File lib/rodauth/features/email_auth.rb
185 def _email_auth_request
186   if email_auth_email_recently_sent?
187     set_redirect_error_flash email_auth_email_recently_sent_error_flash
188     redirect email_auth_email_recently_sent_redirect
189   end
190 
191   generate_email_auth_key_value
192   transaction do
193     before_email_auth_request
194     create_email_auth_key
195     send_email_auth_email
196     after_email_auth_request
197   end
198 
199   set_notice_flash email_auth_email_sent_notice_flash
200 end

    # File lib/rodauth/features/email_auth.rb
180 def _email_auth_request_and_redirect
181   _email_auth_request
182   redirect email_auth_email_sent_redirect
183 end

    # File lib/rodauth/features/base.rb
673 def _field_attributes(field)
674   nil
675 end

    # File lib/rodauth/features/base.rb
677 def _field_error_attributes(field)
678   " aria-invalid=\"true\" aria-describedby=\"#{field}_error_message\" "
679 end

    # File lib/rodauth/features/base.rb
681 def _formatted_field_error(field, error)
682   "<span class=\"#{input_field_error_message_class}\" id=\"#{field}_error_message\">#{error}</span>"
683 end

    # File lib/rodauth/features/remember.rb
194 def _get_remember_cookie
195   request.cookies[remember_cookie_key]
196 end

    # File lib/rodauth/features/json.rb
184 def _json_response_body(hash)
185   request.send(:convert_to_json, hash)
186 end

    # File lib/rodauth/features/jwt.rb
110 def _jwt_decode_opts
111   jwt_decode_opts
112 end

    # File lib/rodauth/features/login.rb
149 def _login(auth_type)
150   warn("Deprecated #_login method called, use #login instead.")
151   login(auth_type)
152 end

    # File lib/rodauth/features/login.rb
144 def _login_form_footer
145   return '' if _login_form_footer_links.empty?
146   render('login-form-footer')
147 end

    # File lib/rodauth/features/create_account.rb
117 def _login_form_footer_links
118   super << [10, create_account_path, create_account_link_text]
119 end

    # File lib/rodauth/features/email_auth.rb
170 def _multi_phase_login_forms
171   forms = super
172   forms << [30, email_auth_request_form, :_email_auth_request_and_redirect] if valid_login_entered? && allow_email_auth?
173   forms
174 end

    # File lib/rodauth/features/create_account.rb
121 def _new_account(login)
122   acc = {login_column=>login}
123   unless skip_status_checks?
124     acc[account_status_column] = account_initial_status_value
125   end
126   acc
127 end

    # File lib/rodauth/features/otp.rb
414 def _otp
415   otp_class.new(otp_user_key, :issuer=>otp_issuer, :digits=>otp_digits, :interval=>otp_interval)
416 end

    # File lib/rodauth/features/otp.rb
403 def _otp_add_key(secret)
404   # Uniqueness errors can't be handled here, as we can't be sure the secret provided
405   # is the same as the current secret.
406   otp_key_ds.insert(otp_keys_id_column=>session_value, otp_keys_column=>secret)
407 end

    # File lib/rodauth/features/otp.rb
409 def _otp_key
410   @otp_user_key = nil
411   otp_key_ds.get(otp_keys_column)
412 end

    # File lib/rodauth/features/otp.rb
397 def _otp_tmp_key(secret)
398   @otp_tmp_key = true
399   @otp_user_key = nil
400   @otp_key = secret
401 end

    # File lib/rodauth/features/recovery_codes.rb
260 def _recovery_codes
261   recovery_codes_ds.select_map(recovery_codes_column)
262 end

    # File lib/rodauth/features/json.rb
174 def _return_json_response
175   response.status ||= json_response_error_status if json_response[json_response_error_key]
176   response['Content-Type'] ||= json_response_content_type
177   return_response _json_response_body(json_response)
178 end

    # File lib/rodauth/features/lockout.rb
171 def _setup_account_lockouts_hash(account_id, key)
172   hash = {account_lockouts_id_column=>account_id, account_lockouts_key_column=>key}
173   set_deadline_value(hash, account_lockouts_deadline_column, account_lockouts_deadline_interval)
174   hash
175 end

    # File lib/rodauth/features/sms_codes.rb
499 def _sms
500   sms_ds.first
501 end

   # File lib/rodauth/features/confirm_password.rb
79 def _two_factor_auth_links
80   links = (super if defined?(super)) || []
81   if authenticated_by.length == 1 && !authenticated_by.include?('password') && has_password?
82     links << [5, confirm_password_path, confirm_password_link_text]
83   end
84   links
85 end

    # File lib/rodauth/features/otp.rb
353 def _two_factor_remove_all_from_session
354   two_factor_remove_session('totp')
355   super
356 end

    # File lib/rodauth/features/otp.rb
347 def _two_factor_remove_links
348   links = super
349   links << [20, otp_disable_path, otp_disable_link_text] if otp_exists?
350   links
351 end

    # File lib/rodauth/features/otp.rb
341 def _two_factor_setup_links
342   links = super
343   links << [20, otp_setup_path, otp_setup_link_text] unless otp_exists?
344   links
345 end

   # File lib/rodauth/features/change_login.rb
83 def _update_login(login)
84   updated = nil
85   raised = raises_uniqueness_violation?{updated = update_account({login_column=>login}, account_ds.exclude(login_column=>login)) == 1}
86   if raised
87     set_login_requirement_error_message(:already_an_account_with_this_login, already_an_account_with_this_login_message)
88   end
89   updated && !raised
90 end

    # File lib/rodauth/features/base.rb
805 def _view(meth, page)
806   scope.send(meth, _view_opts(page))
807 end

    # File lib/rodauth/features/base.rb
790 def _view_opts(page)
791   opts = template_opts.dup
792   opts[:locals] = opts[:locals] ? opts[:locals].dup : {}
793   opts[:locals][:rodauth] = self
794   opts[:cache] = cache_templates
795   opts[:cache_key] = :"rodauth_#{page}"
796 
797   opts = scope.send(:find_template, scope.send(:parse_template_opts, page, opts))
798   unless File.file?(scope.send(:template_path, opts))
799     opts[:path] = template_path(page)
800   end
801 
802   opts
803 end

    # File lib/rodauth/features/account_expiration.rb
104 def account_activity_ds(account_id)
105   db[account_activity_table].
106     where(account_activity_id_column=>account_id)
107 end

    # File lib/rodauth/features/base.rb
693 def account_ds(id=account_id)
694   raise ArgumentError, "invalid account id passed to account_ds" unless id
695   ds = db[accounts_table].where(account_id_column=>id)
696   ds = ds.select(*account_select) if account_select
697   ds
698 end

   # File lib/rodauth/features/account_expiration.rb
54 def account_expired?
55   columns = [account_activity_last_activity_column, account_activity_last_login_column, account_activity_expired_column]
56   last_activity, last_login, expired = account_activity_ds(account_id).get(columns)
57   return true if expired
58   timestamp = convert_timestamp(expire_account_on_last_activity? ? last_activity : last_login)
59   return false unless timestamp
60   timestamp < Time.now - expire_account_after
61 end

   # File lib/rodauth/features/account_expiration.rb
35 def account_expired_at
36   get_activity_timestamp(account_id, account_activity_expired_column)
37 end

    # File lib/rodauth/features/email_auth.rb
133 def account_from_email_auth_key(key)
134   @account = _account_from_email_auth_key(key)
135 end

   # File lib/rodauth/features/email_base.rb
65 def account_from_key(token, status_id=nil)
66   id, key = split_token(token)
67   return unless id && key
68 
69   return unless actual = yield(id)
70 
71   unless timing_safe_eql?(key, convert_email_token_key(actual))
72     if hmac_secret && allow_raw_email_token?
73       return unless timing_safe_eql?(key, actual)
74     else
75       return
76     end
77   end
78   ds = account_ds(id)
79   ds = ds.where(account_status_column=>status_id) if status_id && !skip_status_checks?
80   ds.first
81 end

    # File lib/rodauth/features/base.rb
256 def account_from_login(login)
257   @account = _account_from_login(login)
258 end

   # File lib/rodauth/features/jwt_refresh.rb
88 def account_from_refresh_token(token)
89   @account = _account_from_refresh_token(token)
90 end

   # File lib/rodauth/features/password_expiration.rb
45 def account_from_reset_password_key(key)
46   if a = super
47     check_password_change_allowed
48   end
49   a
50 end

    # File lib/rodauth/features/base.rb
354 def account_from_session
355   @account = _account_from_session
356 end

    # File lib/rodauth/features/lockout.rb
222 def account_from_unlock_key(key)
223   @account = _account_from_unlock_key(key)
224 end

    # File lib/rodauth/features/verify_account.rb
203 def account_from_verify_account_key(key)
204   @account = _account_from_verify_account_key(key)
205 end

    # File lib/rodauth/features/verify_login_change.rb
122 def account_from_verify_login_change_key(key)
123   @account = _account_from_verify_login_change_key(key)
124 end

    # File lib/rodauth/features/base.rb
246 def account_id
247   account[account_id_column]
248 end

   # File lib/rodauth/features/verify_account_grace_period.rb
81 def account_in_unverified_grace_period?
82   return false unless account || (session_value && account_from_session)
83   account[account_status_column] == account_unverified_status_value &&
84     verify_account_grace_period &&
85     !verify_account_ds.where(Sequel.date_add(verification_requested_at_column, :seconds=>verify_account_grace_period) > Sequel::CURRENT_TIMESTAMP).empty?
86 end

    # File lib/rodauth/features/base.rb
350 def account_initial_status_value
351   account_open_status_value
352 end

    # File lib/rodauth/features/lockout.rb
295 def account_lockouts_ds(id=account_id)
296   db[account_lockouts_table].where(account_lockouts_id_column=>id)
297 end

    # File lib/rodauth/features/lockout.rb
291 def account_login_failures_ds
292   db[account_login_failures_table].where(account_login_failures_id_column=>account_id)
293 end

    # File lib/rodauth/features/base.rb
276 def account_password_hash_column
277   nil
278 end

    # File lib/rodauth/features/base.rb
685 def account_session_status_filter
686   {account_status_column=>account_open_status_value}
687 end

    # File lib/rodauth/features/webauthn.rb
262 def account_webauthn_ids
263   webauthn_keys_ds.select_map(webauthn_keys_webauthn_id_column)
264 end

    # File lib/rodauth/features/webauthn.rb
266 def account_webauthn_usage
267   webauthn_keys_ds.select_hash(webauthn_keys_webauthn_id_column, webauthn_keys_last_use_column)
268 end

    # File lib/rodauth/features/webauthn.rb
270 def account_webauthn_user_id
271   unless webauthn_id = webauthn_user_ids_ds.get(webauthn_user_ids_webauthn_id_column)
272     webauthn_id = WebAuthn.generate_user_id
273     if e = raised_uniqueness_violation do
274           webauthn_user_ids_ds.insert(
275             webauthn_user_ids_account_id_column => webauthn_account_id,
276             webauthn_user_ids_webauthn_id_column => webauthn_id
277           )
278         end
279       # If two requests to create a webauthn user id are sent at the same time and an insert
280       # is attempted for both, one will fail with a unique constraint violation.  In that case
281       # it is safe for the second one to use the webauthn user id inserted by the other request.
282       # If there is still no webauthn user id at this point, then we'll just reraise the
283       # exception.
284       # :nocov:
285       raise e unless webauthn_id = webauthn_user_ids_ds.get(webauthn_user_ids_webauthn_id_column)
286       # :nocov:
287     end
288   end
289 
290   webauthn_id
291 end

    # File lib/rodauth/features/remember.rb
222 def active_remember_key_ds(id=account_id)
223   remember_key_ds(id).where(Sequel.expr(remember_deadline_column) > Sequel::CURRENT_TIMESTAMP)
224 end

    # File lib/rodauth/features/active_sessions.rb
173 def active_sessions_ds
174   db[active_sessions_table].
175     where(active_sessions_account_id_column=>session_value)
176 end

    # File lib/rodauth/features/active_sessions.rb
142 def active_sessions_insert_hash
143   {active_sessions_account_id_column => session_value, active_sessions_session_id_column => compute_hmac(active_sessions_key)}
144 end

    # File lib/rodauth/features/active_sessions.rb
146 def active_sessions_update_hash
147   {active_sessions_last_use_column => Sequel::CURRENT_TIMESTAMP}
148 end

   # File lib/rodauth/features/active_sessions.rb
65 def add_active_session
66   key = generate_active_sessions_key
67   set_session_value(session_id_session_key, key)
68   if e = raises_uniqueness_violation?{active_sessions_ds.insert(active_sessions_insert_hash)}
69     handle_duplicate_active_session_id(e)
70   end
71   nil
72 end

   # File lib/rodauth/features/audit_logging.rb
39 def add_audit_log(account_id, action)
40   if hash = audit_log_insert_hash(account_id, action)
41     audit_log_ds.insert(hash)
42   end
43 end

    # File lib/rodauth/features/base.rb
176 def add_field_error_class(field)
177   if field_error(field)
178     " #{input_field_error_class}"
179   end
180 end

   # File lib/rodauth/features/disallow_password_reuse.rb
25 def add_previous_password_hash(hash) 
26   ds = previous_password_ds
27 
28   unless @dont_check_previous_password
29     keep_before = ds.reverse(previous_password_id_column).
30       limit(nil, previous_passwords_to_check).
31       get(previous_password_id_column)
32 
33     if keep_before
34       ds.where(Sequel.expr(previous_password_id_column) <= keep_before).
35         delete
36     end
37   end
38 
39   # This should never raise uniqueness violations, as it uses a serial primary key
40   ds.insert(previous_password_account_id_column=>account_id, previous_password_hash_column=>hash)
41 end

    # File lib/rodauth/features/recovery_codes.rb
187 def add_recovery_code
188   # This should never raise uniqueness violations unless the recovery code is the same, and the odds of that
189   # are 1/256**32 assuming a good random number generator.  Still, attempt to handle that case by retrying
190   # on such a uniqueness violation.
191   retry_on_uniqueness_violation do
192     recovery_codes_ds.insert(recovery_codes_id_column=>session_value, recovery_codes_column=>new_recovery_code)
193   end
194 end

    # File lib/rodauth/features/recovery_codes.rb
177 def add_recovery_codes(number)
178   return if number <= 0
179   transaction do
180     number.times do
181       add_recovery_code
182     end
183   end
184   remove_instance_variable(:@recovery_codes)
185 end

    # File lib/rodauth/features/remember.rb
173 def add_remember_key
174   hash = {remember_id_column=>account_id, remember_key_column=>remember_key_value}
175   set_deadline_value(hash, remember_deadline_column, remember_deadline_interval)
176 
177   if e = raised_uniqueness_violation{remember_key_ds.insert(hash)}
178     # If inserting into the remember key table causes a violation, we can pull the
179     # existing row from the table.  If there is no invalid row, we can then reraise.
180     raise e unless @remember_key_value = active_remember_key_ds.get(remember_key_column)
181   end
182 end

    # File lib/rodauth/features/recovery_codes.rb
151 def add_webauthn_credential(_)
152   super if defined?(super)
153   auto_add_missing_recovery_codes
154 end

   # File lib/rodauth/features/change_password_notify.rb
11 def after_change_password
12   super
13   send_password_changed_email
14 end

    # File lib/rodauth/features/account_expiration.rb
 99 def after_close_account
100   super if defined?(super)
101   account_activity_ds(account_id).delete
102 end

   # File lib/rodauth/features/disallow_password_reuse.rb
87 def after_create_account
88   if account_password_hash_column && !(respond_to?(:verify_account_set_password?) && verify_account_set_password?)
89     add_previous_password_hash(password_hash(param(password_param)))
90   end
91   super if defined?(super)
92 end

    # File lib/rodauth/features/email_auth.rb
208 def after_login
209   # Remove the email auth key after any login, even if
210   # it is a password login.  This is done to invalidate
211   # the email login when a user has a password and requests
212   # email authentication, but then remembers their password
213   # and doesn't need the link.  At that point, the link
214   # that allows login access to the account becomes a
215   # security liability, and it is best to remove it.
216   remove_email_auth_key
217   super
218 end

    # File lib/rodauth/features/email_auth.rb
151 def after_login_entered_during_multi_phase_login
152   # If forcing email auth, just send the email link.
153   _email_auth_request_and_redirect if force_email_auth?
154 
155   super
156 end

    # File lib/rodauth/features/lockout.rb
258 def after_login_failure
259   invalid_login_attempted
260   super
261 end

    # File lib/rodauth/features/remember.rb
198 def after_logout
199   forget_login
200   super if defined?(super)
201 end

    # File lib/rodauth/features/recovery_codes.rb
225 def after_otp_disable
226   super if defined?(super)
227   auto_remove_recovery_codes
228 end

    # File lib/rodauth/features/active_sessions.rb
110 def after_refresh_token
111   super if defined?(super)
112   if prev_key = session[session_id_session_key]
113     key = generate_active_sessions_key
114     set_session_value(session_id_session_key, key)
115     active_sessions_ds.
116       where(active_sessions_session_id_column => compute_hmac(prev_key)).
117       update(active_sessions_session_id_column => compute_hmac(key))
118   end
119 end

   # File lib/rodauth/features/password_grace_period.rb
39 def after_reset_password
40   super if defined?(super)
41   @last_password_entry = Time.now.to_i
42 end

    # File lib/rodauth/features/recovery_codes.rb
230 def after_sms_disable
231   super if defined?(super)
232   auto_remove_recovery_codes
233 end

    # File lib/rodauth/features/recovery_codes.rb
235 def after_webauthn_remove
236   super if defined?(super)
237   auto_remove_recovery_codes
238 end

    # File lib/rodauth/features/email_auth.rb
204 def allow_email_auth?
205   defined?(super) ? super : true
206 end

    # File lib/rodauth/features/verify_account.rb
170 def allow_resending_verify_account_email?
171   account[account_status_column] == account_unverified_status_value
172 end

    # File lib/rodauth/features/base.rb
284 def already_logged_in
285   nil
286 end

   # File lib/rodauth/features/argon2.rb
73 def argon2_hash_algorithm?(hash)
74   hash.start_with?('$argon2id$')
75 end

   # File lib/rodauth/features/argon2.rb
62 def argon2_hash_cost
63   {t_cost: 1, m_cost: 3}
64 end

   # File lib/rodauth/features/argon2.rb
77 def argon2_password_hash_match?(hash, password)
78   ::Argon2::Password.verify_password(password, hash)
79 end

   # File lib/rodauth/features/argon2.rb
20 def argon2_salt_option
21   :salt_do_not_supply
22 end

   # File lib/rodauth/features/audit_logging.rb
83 def audit_log_ds
84   ds = db[audit_logging_table]
85   # :nocov:
86   if db.database_type == :postgres
87   # :nocov:
88     # For PostgreSQL, use RETURNING NULL. This allows the feature
89     # to be used with INSERT but not SELECT permissions on the
90     # table, useful for audit logging where the database user
91     # the application is running as should not need to read the
92     # logs.
93     ds = ds.returning(nil)
94   end
95   ds
96 end

   # File lib/rodauth/features/audit_logging.rb
45 def audit_log_insert_hash(account_id, action)
46   if message = audit_log_message(action)
47     {
48       audit_logging_account_id_column => account_id,
49       audit_logging_message_column => message,
50       audit_logging_metadata_column => serialize_audit_log_metadata(audit_log_metadata(action))
51     }
52   end
53 end

   # File lib/rodauth/features/audit_logging.rb
63 def audit_log_message(action)
64   meth = :"audit_log_message_for_#{action}"
65   if respond_to?(meth, true)
66     send(meth)
67   else
68     audit_log_message_default(action)
69   end
70 end

   # File lib/rodauth/features/audit_logging.rb
59 def audit_log_message_default(action)
60   action.to_s
61 end

   # File lib/rodauth/features/audit_logging.rb
72 def audit_log_metadata(action)
73   meth = :"audit_log_metadata_for_#{action}"
74   if respond_to?(meth, true)
75     send(meth)
76   else
77     audit_log_metadata_default
78   end
79 end

    # File lib/rodauth/features/base.rb
127 def auth_class_eval(&block)
128   auth.class_eval(&block)
129 end

    # File lib/rodauth/features/base.rb
337 def authenticated?
338   logged_in?
339 end

    # File lib/rodauth/features/base.rb
428 def authenticated_by
429   session[authenticated_by_session_key]
430 end

    # File lib/rodauth/features/webauthn.rb
242 def authenticated_webauthn_id
243   session[authenticated_webauthn_id_session_key]
244 end

    # File lib/rodauth/features/recovery_codes.rb
248 def auto_add_missing_recovery_codes
249   if auto_add_recovery_codes?
250     add_recovery_codes(recovery_codes_limit - recovery_codes.length)
251   end
252 end

    # File lib/rodauth/features/recovery_codes.rb
254 def auto_remove_recovery_codes
255   if auto_remove_recovery_codes? && (%w'totp webauthn sms_code' & possible_authentication_methods).empty?
256     recovery_codes_remove
257   end
258 end

    # File lib/rodauth/features/base.rb
206 def autocomplete_for_field?(_param)
207   mark_input_fields_with_autocomplete?
208 end

    # File lib/rodauth/features/base.rb
441 def autologin_session(autologin_type)
442   login_session('autologin')
443   set_session_value(autologin_type_session_key, autologin_type)
444 end

    # File lib/rodauth/features/base.rb
437 def autologin_type
438   session[autologin_type_session_key]
439 end

    # File lib/rodauth/features/otp.rb
392 def base32_encode(data, length)
393   chars = 'abcdefghijklmnopqrstuvwxyz234567'
394   length.times.map{|i|chars[data[i].ord % 32]}.join
395 end

    # File lib/rodauth/features/base.rb
472 def base_url
473   url = String.new("#{request.scheme}://#{domain}")
474   url << ":#{request.port}" if request.port != Rack::Request::DEFAULT_PORTS[request.scheme]
475   url
476 end

   # File lib/rodauth/features/verify_account_grace_period.rb
54 def before_change_login_route
55   unless verified_account?
56     set_redirect_error_flash unverified_change_login_error_flash
57     redirect unverified_change_login_redirect
58   end
59   super if defined?(super)
60 end

   # File lib/rodauth/features/password_expiration.rb
90 def before_change_password_route
91   check_password_change_allowed
92   super
93 end

   # File lib/rodauth/features/disallow_password_reuse.rb
77 def before_create_account_route
78   super if defined?(super)
79   @dont_check_previous_password = true
80 end

    # File lib/rodauth/features/lockout.rb
246 def before_login_attempt
247   if locked_out?
248     show_lockout_page
249   end
250   super
251 end

    # File lib/rodauth/features/active_sessions.rb
126 def before_logout
127   if param_or_nil(global_logout_param)
128     remove_remember_key(session_value) if respond_to?(:remove_remember_key)
129     remove_all_active_sessions
130   else
131     remove_current_session
132   end
133   super
134 end

    # File lib/rodauth/features/json.rb
134 def before_otp_setup_route
135   super if defined?(super)
136   if use_json? && otp_keys_use_hmac? && !param_or_nil(otp_setup_raw_param)
137     _otp_tmp_key(otp_new_secret)
138     json_response[otp_setup_param] = otp_user_key
139     json_response[otp_setup_raw_param] = otp_key
140   end
141 end

   # File lib/rodauth/features/account_expiration.rb
79 def before_reset_password
80   check_account_expiration
81   super if defined?(super)
82 end

   # File lib/rodauth/features/account_expiration.rb
84 def before_reset_password_request
85   check_account_expiration
86   super if defined?(super)
87 end

    # File lib/rodauth/features/json.rb
143 def before_rodauth
144   if json_request?
145     if json_check_accept? && (accept = request.env['HTTP_ACCEPT']) && accept !~ json_accept_regexp
146       response.status = 406
147       json_response[json_response_error_key] = json_not_accepted_error_message
148       _return_json_response
149     end
150 
151     unless request.post?
152       response.status = 405
153       response.headers['Allow'] = 'POST'
154       json_response[json_response_error_key] = json_non_post_error_message
155       return_json_response
156     end
157   elsif only_json?
158     response.status = json_response_error_status
159     return_response non_json_request_error_message
160   end
161 
162   super
163 end

   # File lib/rodauth/features/json.rb
80 def before_two_factor_auth_route
81   super if defined?(super)
82   if use_json?
83     json_response[:auth_links] = two_factor_auth_links.sort.map{|_,link| link}
84     json_response[json_response_success_key] ||= "" if include_success_messages?
85     return_json_response
86   end
87 end

   # File lib/rodauth/features/json.rb
70 def before_two_factor_manage_route
71   super if defined?(super)
72   if use_json?
73     json_response[:setup_links] = two_factor_setup_links.sort.map{|_,link| link}
74     json_response[:remove_links] = two_factor_remove_links.sort.map{|_,link| link}
75     json_response[json_response_success_key] ||= "" if include_success_messages?
76     return_json_response
77   end
78 end

   # File lib/rodauth/features/account_expiration.rb
89 def before_unlock_account
90   check_account_expiration
91   super if defined?(super)
92 end

   # File lib/rodauth/features/account_expiration.rb
94 def before_unlock_account_request
95   check_account_expiration
96   super if defined?(super)
97 end

   # File lib/rodauth/features/webauthn_verify_account.rb
30 def before_verify_account
31   super
32   if features.include?(:json) && use_json? && !param_or_nil(webauthn_setup_param)
33     cred = new_webauthn_credential
34     json_response[webauthn_setup_param] = cred.as_json
35     json_response[webauthn_setup_challenge_param] = cred.challenge
36     json_response[webauthn_setup_challenge_hmac_param] = compute_hmac(cred.challenge)
37   end
38   @webauthn_credential = webauthn_setup_credential_from_form_submission
39   add_webauthn_credential(@webauthn_credential)
40 end

   # File lib/rodauth/features/disallow_password_reuse.rb
82 def before_verify_account_route
83   super if defined?(super)
84   @dont_check_previous_password = true
85 end

   # File lib/rodauth/features/json.rb
89 def before_view_recovery_codes
90   super if defined?(super)
91   if use_json?
92     json_response[:codes] = recovery_codes
93     json_response[json_response_success_key] ||= "" if include_success_messages?
94   end
95 end

    # File lib/rodauth/features/json.rb
107 def before_webauthn_auth_route
108   super if defined?(super)
109   if use_json? && !param_or_nil(webauthn_auth_param)
110     cred = webauth_credential_options_for_get
111     json_response[webauthn_auth_param] = cred.as_json
112     json_response[webauthn_auth_challenge_param] = cred.challenge
113     json_response[webauthn_auth_challenge_hmac_param] = compute_hmac(cred.challenge)
114   end
115 end

    # File lib/rodauth/features/json.rb
117 def before_webauthn_login_route
118   super if defined?(super)
119   if use_json? && !param_or_nil(webauthn_auth_param) && account_from_login(param(login_param))
120     cred = webauth_credential_options_for_get
121     json_response[webauthn_auth_param] = cred.as_json
122     json_response[webauthn_auth_challenge_param] = cred.challenge
123     json_response[webauthn_auth_challenge_hmac_param] = compute_hmac(cred.challenge)
124   end
125 end

    # File lib/rodauth/features/json.rb
127 def before_webauthn_remove_route
128   super if defined?(super)
129   if use_json? && !param_or_nil(webauthn_remove_param)
130     json_response[webauthn_remove_param] = account_webauthn_usage
131   end
132 end

    # File lib/rodauth/features/json.rb
 97 def before_webauthn_setup_route
 98   super if defined?(super)
 99   if use_json? && !param_or_nil(webauthn_setup_param)
100     cred = new_webauthn_credential
101     json_response[webauthn_setup_param] = cred.as_json
102     json_response[webauthn_setup_challenge_param] = cred.challenge
103     json_response[webauthn_setup_challenge_hmac_param] = compute_hmac(cred.challenge)
104   end
105 end

    # File lib/rodauth/features/base.rb
383 def button(value, opts={})
384   scope.render(button_opts(value, opts))
385 end

    # File lib/rodauth/features/base.rb
374 def button_opts(value, opts)
375   opts = Hash[template_opts].merge!(opts)
376   opts[:locals] = {:value=>value, :opts=>opts}
377   opts[:path] = template_path('button')
378   opts[:cache] = cache_templates
379   opts[:cache_key] = :rodauth_button
380   opts
381 end

    # File lib/rodauth/features/recovery_codes.rb
173 def can_add_recovery_codes?
174   recovery_codes.length < recovery_codes_limit
175 end

    # File lib/rodauth/features/base.rb
560 def catch_error(&block)
561   catch(:rodauth_error, &block)
562 end

   # File lib/rodauth/features/change_login.rb
68 def change_login(login)
69   if account_ds.get(login_column).downcase == login.downcase
70     set_login_requirement_error_message(:same_as_current_login, same_as_current_login_message)
71     return false
72   end
73 
74   update_login(login)
75 end

    # File lib/rodauth/features/verify_login_change.rb
138 def change_login_notice_flash
139   change_login_needs_verification_notice_flash
140 end

   # File lib/rodauth/features/change_login.rb
64 def change_login_requires_password?
65   modifications_require_password?
66 end

   # File lib/rodauth/features/change_password.rb
68 def change_password_requires_password?
69   modifications_require_password?
70 end

   # File lib/rodauth/features/account_expiration.rb
63 def check_account_expiration
64   if account_expired?
65     set_expired unless account_expired_at
66     set_redirect_error_flash account_expiration_error_flash
67     redirect account_expiration_redirect
68   end
69   update_last_login
70 end

   # File lib/rodauth/features/active_sessions.rb
51 def check_active_session
52   if logged_in? && !currently_active_session?
53     no_longer_active_session
54   end
55 end

    # File lib/rodauth/features/base.rb
280 def check_already_logged_in
281   already_logged_in if logged_in?
282 end

    # File lib/rodauth/features/base.rb
358 def check_csrf
359   scope.check_csrf!(check_csrf_opts, &check_csrf_block)
360 end

    # File lib/rodauth/features/base.rb
618 def check_csrf?
619   scope.opts[:rodauth_route_csrf]
620 end

   # File lib/rodauth/features/password_expiration.rb
30 def check_password_change_allowed
31   if password_changed_at = get_password_changed_at
32     if password_changed_at > Time.now - allow_password_change_after
33       set_redirect_error_flash password_not_changeable_yet_error_flash
34       redirect password_not_changeable_yet_redirect
35     end
36   end
37 end

   # File lib/rodauth/features/session_expiration.rb
15 def check_session_expiration
16   return unless logged_in?
17 
18   unless session.has_key?(session_last_activity_session_key) && session.has_key?(session_created_session_key)
19     if session_expiration_default
20       expire_session
21     end
22 
23     return
24   end
25 
26   time = Time.now.to_i
27 
28   if session[session_last_activity_session_key] + session_inactivity_timeout < time
29     expire_session
30   end
31   set_session_value(session_last_activity_session_key, time)
32 
33   if session[session_created_session_key] + max_session_lifetime < time
34     expire_session
35   end
36 end

   # File lib/rodauth/features/single_session.rb
51 def check_single_session
52   if logged_in? && !currently_active_session?
53     no_longer_active_session
54   end
55 end

    # File lib/rodauth/features/otp.rb
358 def clear_cached_otp
359   remove_instance_variable(:@otp) if defined?(@otp)
360 end

    # File lib/rodauth/features/lockout.rb
167 def clear_invalid_login_attempts
168   unlock_account
169 end

    # File lib/rodauth/features/base.rb
296 def clear_session
297   if scope.respond_to?(:clear_session)
298     scope.clear_session
299   else
300     session.clear
301   end
302 end

   # File lib/rodauth/features/close_account.rb
66 def close_account
67   unless skip_status_checks?
68     update_account(account_status_column=>account_closed_status_value)
69   end
70 
71   unless account_password_hash_column
72     password_hash_ds.delete
73   end
74 end

   # File lib/rodauth/features/close_account.rb
62 def close_account_requires_password?
63   modifications_require_password?
64 end

    # File lib/rodauth/features/base.rb
240 def compute_hmac(data)
241   s = [compute_raw_hmac(data)].pack('m').chomp!("=\n")
242   s.tr!('+/', '-_')
243   s
244 end

    # File lib/rodauth/features/base.rb
669 def compute_raw_hmac(data)
670   OpenSSL::HMAC.digest(OpenSSL::Digest::SHA256.new, hmac_secret, data)
671 end

   # File lib/rodauth/features/confirm_password.rb
63 def confirm_password
64   authenticated_by.delete('autologin')
65   authenticated_by.delete('remember')
66   authenticated_by.delete('email_auth')
67   authenticated_by.delete('password')
68   authenticated_by.unshift("password")
69   remove_session_value(autologin_type_session_key)
70   nil
71 end

   # File lib/rodauth/features/confirm_password.rb
73 def confirm_password_redirect
74   remove_session_value(confirm_password_redirect_session_key) || default_redirect
75 end

   # File lib/rodauth/features/email_base.rb
61 def convert_email_token_key(key)
62   convert_token_key(key)
63 end

    # File lib/rodauth/features/base.rb
543 def convert_session_key(key)
544   key = "#{session_key_prefix}#{key}".to_sym if session_key_prefix
545   scope.opts[:sessions_convert_symbols] ? key.to_s : key
546 end

    # File lib/rodauth/features/base.rb
705 def convert_timestamp(timestamp)
706   timestamp = db.to_application_timestamp(timestamp) if timestamp.is_a?(String)
707   timestamp
708 end

    # File lib/rodauth/features/base.rb
504 def convert_token_key(key)
505   if key && hmac_secret
506     compute_hmac(key)
507   else
508     key
509   end
510 end

    # File lib/rodauth/features/verify_account.rb
223 def create_account_autologin?
224   false
225 end

    # File lib/rodauth/features/verify_account.rb
190 def create_account_notice_flash
191   verify_account_email_sent_notice_flash
192 end

    # File lib/rodauth/features/verify_account.rb
227 def create_account_set_password?
228   return false if verify_account_set_password?
229   super
230 end

   # File lib/rodauth/features/email_base.rb
32 def create_email(subject, body)
33   create_email_to(email_to, subject, body)
34 end

    # File lib/rodauth/features/email_auth.rb
104 def create_email_auth_key
105   transaction do
106     if email_auth_key_value = get_email_auth_key(account_id)
107       set_email_auth_email_last_sent
108       @email_auth_key_value = email_auth_key_value
109     elsif e = raised_uniqueness_violation{email_auth_ds.insert(email_auth_key_insert_hash)}
110       # If inserting into the email auth table causes a violation, we can pull the
111       # existing email auth key from the table, or reraise.
112       raise e unless @email_auth_key_value = get_email_auth_key(account_id)
113     end
114   end
115 end

   # File lib/rodauth/features/email_base.rb
36 def create_email_to(to, subject, body)
37   m = Mail.new
38   m.from = email_from
39   m.to = to
40   m.subject = "#{email_subject_prefix}#{subject}"
41   m.body = body
42   m
43 end

    # File lib/rodauth/features/reset_password.rb
166 def create_reset_password_key
167   transaction do
168     if reset_password_key_value = get_password_reset_key(account_id)
169       set_reset_password_email_last_sent
170       @reset_password_key_value = reset_password_key_value
171     elsif e = raised_uniqueness_violation{password_reset_ds.insert(reset_password_key_insert_hash)}
172       # If inserting into the reset password table causes a violation, we can pull the
173       # existing reset password key from the table, or reraise.
174       raise e unless @reset_password_key_value = get_password_reset_key(account_id)
175     end
176   end
177 end

    # File lib/rodauth/features/verify_account.rb
288 def create_verify_account_key
289   ds = verify_account_ds
290   transaction do
291     if ds.empty?
292       if e = raised_uniqueness_violation{ds.insert(verify_account_key_insert_hash)}
293         # If inserting into the verify account table causes a violation, we can pull the
294         # key from the verify account table, or reraise.
295         raise e unless @verify_account_key_value = get_verify_account_key(account_id)
296       end
297     end
298   end
299 end

    # File lib/rodauth/features/verify_login_change.rb
200 def create_verify_login_change_email(login)
201   create_email_to(login, verify_login_change_email_subject, verify_login_change_email_body)
202 end

    # File lib/rodauth/features/verify_login_change.rb
178 def create_verify_login_change_key(login)
179   ds = verify_login_change_ds
180   transaction do
181     ds.where((Sequel::CURRENT_TIMESTAMP > verify_login_change_deadline_column) | ~Sequel.expr(verify_login_change_login_column=>login)).delete
182     if e = raised_uniqueness_violation{ds.insert(verify_login_change_key_insert_hash(login))}
183       old_login, key = get_verify_login_change_login_and_key(account_id)
184       # If inserting into the verify login change table causes a violation, we can pull the
185       # key from the verify login change table if the logins match, or reraise.
186       @verify_login_change_key_value = if old_login.downcase == login.downcase
187         key
188       end
189       raise e unless @verify_login_change_key_value
190     end
191   end
192 end

    # File lib/rodauth/features/base.rb
362 def csrf_tag(path=request.path)
363   return unless scope.respond_to?(:csrf_tag)
364 
365   if use_request_specific_csrf_tokens?
366     scope.csrf_tag(path)
367   else
368     # :nocov:
369     scope.csrf_tag
370     # :nocov:
371   end
372 end

   # File lib/rodauth/features/active_sessions.rb
37 def currently_active_session?
38   return false unless session_id = session[session_id_session_key]
39 
40   remove_inactive_sessions
41   ds = active_sessions_ds.
42     where(active_sessions_session_id_column => compute_hmac(session_id))
43 
44   if update_current_session?
45     ds.update(active_sessions_update_hash) == 1
46   else
47     ds.count == 1
48   end
49 end

    # File lib/rodauth/features/base.rb
496 def database_function_password_match?(name, hash_id, password, salt)
497   db.get(Sequel.function(function_name(name), hash_id, password_hash_using_salt(password, salt)))
498 end

    # File lib/rodauth/features/base.rb
264 def db
265   Sequel::DATABASES.first
266 end

   # File lib/rodauth/features/close_account.rb
76 def delete_account
77   account_ds.delete
78 end

   # File lib/rodauth/features/close_account.rb
80 def delete_account_on_close?
81   skip_status_checks?
82 end

    # File lib/rodauth/features/remember.rb
169 def disable_remember_login
170   remove_remember_key
171 end

    # File lib/rodauth/features/base.rb
478 def domain
479   request.host
480 end

    # File lib/rodauth/features/email_auth.rb
239 def email_auth_ds(id=account_id)
240   db[email_auth_table].where(email_auth_id_column=>id)
241 end

    # File lib/rodauth/features/email_auth.rb
137 def email_auth_email_link
138   token_link(email_auth_route, email_auth_key_param, email_auth_key_value)
139 end

    # File lib/rodauth/features/email_auth.rb
176 def email_auth_email_recently_sent?
177   (email_last_sent = get_email_auth_email_last_sent) && (Time.now - email_last_sent < email_auth_skip_resend_email_within)
178 end

    # File lib/rodauth/features/email_auth.rb
233 def email_auth_key_insert_hash
234   hash = {email_auth_id_column=>account_id, email_auth_key_column=>email_auth_key_value}
235   set_deadline_value(hash, email_auth_deadline_column, email_auth_deadline_interval)
236   hash
237 end

    # File lib/rodauth/features/email_auth.rb
147 def email_auth_request_form
148   render('email-auth-request-form')
149 end

   # File lib/rodauth/features/email_base.rb
45 def email_from
46   "webmaster@#{domain}"
47 end

   # File lib/rodauth/features/email_base.rb
49 def email_to
50   account[login_column]
51 end

   # File lib/rodauth/features/session_expiration.rb
38 def expire_session
39   clear_session
40   set_redirect_error_status session_expiration_error_status
41   set_error_reason :session_expired
42   set_redirect_error_flash session_expiration_error_flash
43   redirect session_expiration_redirect
44 end

   # File lib/rodauth/features/argon2.rb
54 def extract_password_hash_cost(hash)
55   return super unless argon2_hash_algorithm?(hash )
56 
57   /\A\$argon2id\$v=\d+\$m=(\d+),t=(\d+)/ =~ hash
58   { t_cost: $2.to_i, m_cost: Math.log2($1.to_i).to_i }
59 end

    # File lib/rodauth/features/base.rb
139 def features
140   self.class.features
141 end

    # File lib/rodauth/features/base.rb
214 def field_attributes(field)
215   _field_attributes(field) || default_field_attributes
216 end

    # File lib/rodauth/features/base.rb
171 def field_error(field)
172   return nil unless @field_errors
173   @field_errors[field]
174 end

    # File lib/rodauth/features/base.rb
218 def field_error_attributes(field)
219   if field_error(field)
220     _field_error_attributes(field)
221   end
222 end

    # File lib/rodauth/features/base.rb
155 def flash
156   scope.flash
157 end

    # File lib/rodauth/features/remember.rb
152 def forget_login
153   opts = Hash[remember_cookie_options]
154   opts[:path] = "/" unless opts.key?(:path)
155   ::Rack::Utils.delete_cookie_header!(response.headers, remember_cookie_key, opts)
156 end

    # File lib/rodauth/features/base.rb
224 def formatted_field_error(field)
225   if error = field_error(field)
226     _formatted_field_error(field, error)
227   end
228 end

    # File lib/rodauth/features/base.rb
622 def function_name(name)
623   if db.database_type == :mssql
624     # :nocov:
625     "dbo.#{name}"
626     # :nocov:
627   else
628     name
629   end
630 end

    # File lib/rodauth/features/active_sessions.rb
138 def generate_active_sessions_key
139   @active_sessions_key = random_key
140 end

    # File lib/rodauth/features/email_auth.rb
225 def generate_email_auth_key_value
226   @email_auth_key_value = random_key
227 end

    # File lib/rodauth/features/jwt_refresh.rb
181 def generate_refresh_token
182   hash = jwt_refresh_token_insert_hash
183   [account_id, jwt_refresh_token_ds.insert(hash), convert_token_key(hash[jwt_refresh_token_key_column])].join(token_separator)
184 end

    # File lib/rodauth/features/remember.rb
210 def generate_remember_key_value
211   @remember_key_value = random_key
212 end

    # File lib/rodauth/features/reset_password.rb
233 def generate_reset_password_key_value
234   @reset_password_key_value = random_key
235 end

    # File lib/rodauth/features/lockout.rb
268 def generate_unlock_account_key
269   random_key
270 end

    # File lib/rodauth/features/verify_account.rb
284 def generate_verify_account_key_value
285   @verify_account_key_value = random_key
286 end

    # File lib/rodauth/features/verify_login_change.rb
174 def generate_verify_login_change_key_value
175   @verify_login_change_key_value = random_key
176 end

    # File lib/rodauth/features/jwt_refresh.rb
154 def get_active_refresh_token(account_id, token_id)
155   jwt_refresh_token_account_ds(account_id).
156     where(Sequel::CURRENT_TIMESTAMP > jwt_refresh_token_deadline_column).
157     delete
158 
159   jwt_refresh_token_account_token_ds(account_id, token_id).
160     get(jwt_refresh_token_key_column)
161 end

    # File lib/rodauth/features/account_expiration.rb
109 def get_activity_timestamp(account_id, column)
110   convert_timestamp(account_activity_ds(account_id).get(column))
111 end

    # File lib/rodauth/features/email_auth.rb
121 def get_email_auth_email_last_sent
122   if column = email_auth_email_last_sent_column
123     if ts = email_auth_ds.get(column)
124       convert_timestamp(ts)
125     end
126   end
127 end

    # File lib/rodauth/features/email_auth.rb
141 def get_email_auth_key(id)
142   ds = email_auth_ds(id)
143   ds.where(Sequel::CURRENT_TIMESTAMP > email_auth_deadline_column).delete
144   ds.get(email_auth_key_column)
145 end

   # File lib/rodauth/features/password_expiration.rb
26 def get_password_changed_at
27   convert_timestamp(password_expiration_ds.get(password_expiration_changed_at_column))
28 end

    # File lib/rodauth/features/base.rb
644 def get_password_hash
645   if account_password_hash_column
646     (account || account_from_session)[account_password_hash_column]
647   elsif use_database_authentication_functions?
648     db.get(Sequel.function(function_name(:rodauth_get_salt), account ? account_id : session_value))
649   else
650     # :nocov:
651     password_hash_ds.get(password_hash_column)
652     # :nocov:
653   end
654 end