Inicio de sesión automático con rieles?

Question

Estoy tratando de conseguir un sistema de autenticación simple con el plugin de autenticación-reparador de Rails, y estoy preguntando cómo funciona, b / c que parece que no puede averiguar cuáles son los requisitos para las cookies, y cómo que sea lo que el navegador siempre se acuerda de ti (para 6+ meses).

Pocas preguntas:

1) ¿Cómo está usted de remember_me para restful_authentication de rubí? Me parece que no puede encontrar una buena de una sola línea para resolver este problema ...

Si un usuario se inscribe y cheques "Remember Me", ¿cómo la aplicación rieles obtener la sesión / galletas sin que el usuario hacer otra cosa que ir a la página de la próxima vez que vayan a la página, por ejemplo 3 meses más tarde?

2) ¿Es necesario enviar algún tipo de información al servidor, como su dirección IP o algo? ¿Cuál es cookies[:auth_token], donde se define que?

El objetivo es: Yo no quiero que tengan que introducir su correo electrónico / contraseña de nuevo, al igual que cómo funciona Stackoverflow:)

Answer 1

Esto es lo que estamos haciendo (en gran parte tomada de sistema autenticado) ... este es el método de control que se encarga de inicio de sesión que se nos está acabando ...

def login
  if logged_in?
    flash[:notice] = "You are already logged in."
    redirect_to "/" and return
  end
  unless request.post?
    render :layout => 'task' and return
  end
  self.current_user = User.authenticate(params[:login], params[:password])
  if logged_in?
    if params[:remember_me].to_i == 1
      self.current_user.remember_me
      cookies[:auth_token] = {:domain => "#{DOMAIN}", :value => self.current_user.remember_token , :expires => self.current_user.remember_token_expires_at }
    else
      self.current_user.forget_me
      cookies.delete(:auth_token, :domain => "#{DOMAIN}")
      cookies[:auth_token] = nil
    end
    current_user.last_seen_at = Time.now 
    current_user.save
    session[:notice] = "You logged in successfully"
    flash[:notice] = "You logged in successfully"
    redirect_back_or_default(:controller => 'dashboard') and return
    #redirect_back_or_default(:controller => 'index', :action => 'index') and return
  else
    if $failed_login_counter.add_attempt(params[:login]) > MAXIMUM_LOGIN_ATTEMPTS
      logger.info("login rate limiter kicking in, #{MAXIMUM_LOGIN_ATTEMPTS} login attempts failed")
      redirect_to "/denied.html" and return
    end
    flash[:error] = "Unable to authenticate username and password"
    render(:layout => 'task') and return
  end
end

Y utilizar esto para cierre de sesión

def logout
  current_user.last_seen_at = Time.now 
  current_user.save
  self.current_user.forget_me if logged_in?
  cookies.delete(:auth_token, :domain => "#{DOMAIN}")
  reset_session
  flash[:notice] = "You have been logged out."
  #redirect_to :back
  redirect_back_or_default(:controller => 'index', :action => 'index') and return
end

A continuación, - en su application.rb que necesita algo como:

before_filter :login_from_cookie

def login_from_cookie
  return unless cookies[:auth_token] && !logged_in?
  user = User.find_by_remember_token(cookies[:auth_token])
  if user && user.remember_token?
    user.remember_me
    self.current_user = user
    cookies[:auth_token] = { :domain => "#{DOMAIN}", :value => self.current_user.remember_token , :expires => self.current_user.remember_token_expires_at }
    flash[:notice] = "#{self.current_user.login}, you have logged in successfully"
  end
end

Y - en su modelo de usuario tener algunos métodos como éste:

# Encrypts some data with the salt.
def self.encrypt(password, salt)
  Digest::SHA1.hexdigest("--#{salt}--#{password}--")
end

# Encrypts the password with the user salt
def encrypt(password)
  self.class.encrypt(password, salt)
end

def remember_token?
  remember_token_expires_at && Time.now.utc < remember_token_expires_at 
end

# These create and unset the fields required for remembering users between browser closes
def remember_me
  self.remember_token_expires_at = 2.weeks.from_now.utc
  self.remember_token            = encrypt("#{email}--#{remember_token_expires_at}")
  save(false)
end

def forget_me
  self.remember_token_expires_at = nil
  self.remember_token            = nil
  save(false)
end

Answer 2

No estoy seguro de honestidad aboout que la aplicación en particular. Pero un método REST común de autenticación es pasar una versión hash de usuario / contraseña con cada solicitud como una cabecera. Alternativamente, puede utilizar un valor de cookie con hash como un encabezado.

También he visto sistemas híbridos que involucran tanto. Se pasa en la sesión, si lo conoce, además de que el usuario / pass. Luego del lado del servidor si la sesión es válida y que utiliza y que puede almacenar en caché la sesión -> relación de usuario para el rendimiento. Si la sesión no es válido, se intenta autenticar mediante el / pase usuario.

En este tipo de sistema que le pasa la sesión de nuevo en la respuesta como una cabecera.

Por supuesto que es sólo un pequeño repaso de cómo un sistema puede trabajar, no cómo la biblioteca de rubí hace.

Answer 3

Puede encontrar aquí todo un tutorial acerca de la autenticación de descanso. http://railsforum.com/viewtopic.php?id=14216&p=13