Automatische Anmeldung mit Rails?

Question

Ich versuche, ein einfaches Authentifizierungssystem mit Rails' Erholsamer-Authentifizierungs-Plugin, um aufzustehen, und ich frage mich nur, wie es funktioniert, b / c ich nicht herausfinden kann, scheinen, was die Anforderungen für Cookies sind und wie man machen es so den Browser, den Sie immer erinnert (für 6 + Monate).

Ein paar Fragen:

1) Wie beurteilen Sie Remember_Me die für Rubys restful_authentication tun? Ich kann nicht dieses Problem zu lösen scheinen eine gute Einzeiler zu finden ...

Wenn ein Benutzer anmeldet und überprüft, „Remember Me“, wie funktioniert die Rails-Anwendung erhalten die Session / Cookie ohne dass der Benutzer etwas zu tun, aber das nächste Mal, wenn sie auf die Seite gehen, sagen Sie zu der Seite gehen 3 Monate später?

2) Muss ich irgendeine Art von Informationen an den Server, wie ihre IP-Adresse oder etwas schicken? Was ist cookies[:auth_token], wo das definiert ist?

Das Ziel ist: Ich will sie nicht ihr E-Mail / Passwort erneut eingeben müssen, wie, wie Stackoverflow funktioniert:)

Answer 1

Hier ist, was wir tun (weitgehend von authentifizierten System genommen) ... dies die Controller-Methode ist, dass Griffe anmelden, dass wir laufen ...

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

Und verwenden Sie diese für Abmelde

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

Dann - in Ihrem application.rb Sie wie etwas brauchen:

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

Und - in Ihrem User-Modell einige Methoden wie diese:

# 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

Ich bin ehrlich gesagt nicht sicher aboout diese bestimmte Implementierung. Aber eine gemeinsame RESTful Methode der Authentifizierung ist eine Hash-Version des Benutzer / Passwort mit jeder Anforderung als Header zu übergeben. Alternativ können Sie einen Hash-Cookie-Wert als Header verwendet werden.

Ich habe auch hybride Systeme gesehen, die beide betreffen. Sie passieren in der Sitzung, wenn Sie es, zusätzlich zu dem Benutzer / Pass kennen. Dann Server-Seite, wenn die Sitzung gültig ist verwendet es das und die Sitzung zwischenspeichern kann -> Benutzer Beziehung für die Leistung. Wenn die Sitzung ungültig ist, versucht er, die Authentifizierung der Benutzer / Pass verwendet wird.

Bei dieser Art von System würde Sie die Sitzung wieder auf die Antwort als Header übergeben.

Natürlich, das ist nur ein kurzer Überblick darüber, wie ein System funktionieren könnte, nicht, wie Rubin Bibliothek der Fall ist.

Answer 3

Sie können hier eine ganze Tutorial über erholsame Authentifizierung finden. http://railsforum.com/viewtopic.php?id=14216&p=13