Remember me functionality in Ruby on Rails

Introduction

The "Remember me" feature helps users stay logged in even after closing the browser. It makes returning to a website easier without typing the password again.

When users want to stay logged in on their personal device.

For websites where frequent login is annoying, like social media or email.

To improve user experience by reducing login steps.

When users prefer convenience over security on trusted devices.

Syntax

Ruby on Rails

class User < ApplicationRecord
  attr_accessor :remember_token

  # Generates a new token
  def self.new_token
    SecureRandom.urlsafe_base64
  end

  # Saves a hashed token to the database
  def remember
    self.remember_token = User.new_token
    update_attribute(:remember_digest, BCrypt::Password.create(remember_token))
  end

  # Checks if token matches digest
  def authenticated?(token)
    return false if remember_digest.nil?
    BCrypt::Password.new(remember_digest).is_password?(token)
  end

  # Forgets the user
  def forget
    update_attribute(:remember_digest, nil)
  end
end

The remember_token is a temporary token stored in memory.

The remember_digest is saved in the database securely.

Examples

This method creates a token and stores its hashed version in the database.

Ruby on Rails

user.remember
# Generates token and saves digest

Stores user ID and token in cookies to keep user logged in.

Ruby on Rails

cookies.permanent.signed[:user_id] = user.id
cookies.permanent[:remember_token] = user.remember_token

Retrieves the current user by checking cookies and verifying the token.

Ruby on Rails

def current_user
  if (user_id = cookies.signed[:user_id])
    user = User.find_by(id: user_id)
    if user&.authenticated?(cookies[:remember_token])
      @current_user = user
    end
  end
end

Sample Program

This example shows how to create a remember token, save its digest, and verify it. It prints the token and checks authentication with correct and wrong tokens.

Ruby on Rails

class User < ApplicationRecord
  attr_accessor :remember_token

  def self.new_token
    SecureRandom.urlsafe_base64
  end

  def remember
    self.remember_token = User.new_token
    update_attribute(:remember_digest, BCrypt::Password.create(remember_token))
  end

  def authenticated?(token)
    return false if remember_digest.nil?
    BCrypt::Password.new(remember_digest).is_password?(token)
  end

  def forget
    update_attribute(:remember_digest, nil)
  end
end

# Simulate user login and remember me
user = User.new
user.remember
puts "Remember token: #{user.remember_token}"
puts "Authenticated with correct token: #{user.authenticated?(user.remember_token)}"
puts "Authenticated with wrong token: #{user.authenticated?("wrongtoken")}"

Important Notes

Always store only hashed tokens in the database for security.

Use secure, signed cookies to prevent tampering.

Remember to clear the token on logout to protect user accounts.

Summary

"Remember me" keeps users logged in by storing a secure token.

Tokens are hashed before saving to protect user data.

Cookies store the token and user ID to identify returning users.

Practice

1. What is the main purpose of the remember me functionality in a Rails application?

easy

A. To reset the user's password automatically

B. To keep users logged in by saving a cookie on their browser

C. To log out users after a short time

D. To encrypt all user data in the database

Solution

1. Step 1: Understand the purpose of remember me

   The remember me feature is designed to keep users logged in even after they close their browser by saving a cookie.

2. Step 2: Identify the correct description

   Options B, C, and D describe unrelated features like password reset, forced logout, or data encryption, which are not the purpose of remember me.

3. Final Answer:

   To keep users logged in by saving a cookie on their browser -> Option B

4. Quick Check:

   Remember me = save cookie to stay logged in [OK]

Hint: Remember me means saving login info in a cookie [OK]

Common Mistakes:

• Confusing remember me with password reset
• Thinking it logs out users quickly
• Assuming it encrypts database data

2. Which of the following is the correct way to set a permanent signed cookie for remember me in Rails?

easy

A. cookies.signed[:user_id] = { value: user.id, expires: 20.years.from_now }

B. cookies[:user_id] = { value: user.id, expires: 1.hour.from_now }

C. session[:user_id] = user.id

D. cookies.permanent[:user_id] = user.id

Solution

1. Step 1: Understand permanent signed cookies

   Permanent signed cookies in Rails are set with cookies.signed and an expiration far in the future, like 20 years.

2. Step 2: Analyze options

   cookies[:user_id] = { value: user.id, expires: 1.hour.from_now } sets a cookie but expires in 1 hour, not permanent. session[:user_id] = user.id uses session, not cookie. cookies.permanent[:user_id] = user.id sets a permanent cookie but not signed, which is less secure.

3. Final Answer:

   cookies.signed[:user_id] = { value: user.id, expires: 20.years.from_now } -> Option A

4. Quick Check:

   Permanent signed cookie = cookies.signed with long expiry [OK]

Hint: Use cookies.signed with long expiry for remember me [OK]

Common Mistakes:

• Using session instead of cookies
• Setting short expiry for permanent cookie
• Not signing the cookie for security

3. Given this Rails controller code snippet for login:

def create
  user = User.find_by(email: params[:email])
  if user&.authenticate(params[:password])
    if params[:remember_me] == '1'
      cookies.permanent.signed[:user_id] = user.id
    else
      session[:user_id] = user.id
    end
    redirect_to root_path
  else
    render :new
  end
end

What happens if the user checks the 'remember me' box?

medium

A. User ID is saved only in the session and lost on browser close

B. User password is saved in a cookie

C. User is logged out immediately

D. User ID is saved in a permanent signed cookie to keep logged in

Solution

1. Step 1: Check the remember_me condition

   If params[:remember_me] == '1', the code sets cookies.permanent.signed[:user_id] = user.id, which saves a permanent signed cookie.

2. Step 2: Understand cookie effect

   This cookie keeps the user logged in even after closing the browser, unlike session which clears on close.

3. Final Answer:

   User ID is saved in a permanent signed cookie to keep logged in -> Option D

4. Quick Check:

   Remember me checked = permanent signed cookie set [OK]

Hint: Remember me checked sets permanent signed cookie [OK]

Common Mistakes:

• Thinking session is used when remember me is checked
• Assuming password is saved in cookie
• Believing user logs out immediately

4. Identify the bug in this logout method related to remember me functionality:

def destroy
  session.delete(:user_id)
  cookies.delete(:user_id)
  redirect_to login_path
end

medium

A. It does not clear the user's password

B. It deletes the cookie but not the session

C. It deletes the session but forgets to delete the signed cookie

D. It redirects to the wrong path

Solution

1. Step 1: Check what is deleted

   The method deletes session[:user_id] and cookies[:user_id], but the remember me cookie is usually a signed cookie.

2. Step 2: Understand cookie deletion

   Deleting cookies[:user_id] does not remove cookies.signed[:user_id]. The signed cookie remains, so user stays logged in.

3. Final Answer:

   It deletes the session but forgets to delete the signed cookie -> Option C

4. Quick Check:

   Logout must delete signed cookie too [OK]

Hint: Delete signed cookie on logout, not just plain cookie [OK]

Common Mistakes:

• Deleting only session but not signed cookie
• Deleting wrong cookie key
• Not redirecting after logout

5. You want to implement a secure remember me feature that expires after 2 weeks and invalidates on logout. Which approach is best?

hard

A. Set cookies.signed[:user_id] with 2 weeks expiry and delete it on logout

B. Store user ID in session only and never use cookies

C. Save user password in a permanent cookie for quick login

D. Use a plain cookie without signing or expiry

Solution

1. Step 1: Choose secure cookie with expiry

   Using cookies.signed[:user_id] with a 2 weeks expiry ensures the cookie is secure and expires reasonably.

2. Step 2: Invalidate cookie on logout

   Deleting this cookie on logout prevents unauthorized access after user logs out.

3. Final Answer:

   Set cookies.signed[:user_id] with 2 weeks expiry and delete it on logout -> Option A

4. Quick Check:

   Secure signed cookie + expiry + delete on logout = best practice [OK]

Hint: Use signed cookie with expiry and delete on logout [OK]

Common Mistakes:

• Storing password in cookie (insecure)
• Using session only (no persistence after close)
• Using unsigned or permanent cookies without expiry