From 9f94a70c3e3d9bf766cb9663b0a904d30a190d85 Mon Sep 17 00:00:00 2001 From: simon Date: Sun, 8 Feb 2009 23:15:11 +0100 Subject: * initial commit of the stripped restful-authentication * http basic auth and login from cookie have been removed * no it does not work yet, it's so f*cking secure, it won't even let legitimate users login --- lib/authenticated_system.rb | 127 +++++++++++++++++++++++++++++++++++++++ lib/authenticated_test_helper.rb | 6 ++ lib/authentication.rb | 103 +++++++++++++++++++++++++++++++ 3 files changed, 236 insertions(+) create mode 100644 lib/authenticated_system.rb create mode 100644 lib/authenticated_test_helper.rb create mode 100644 lib/authentication.rb (limited to 'lib') diff --git a/lib/authenticated_system.rb b/lib/authenticated_system.rb new file mode 100644 index 0000000..7b813f4 --- /dev/null +++ b/lib/authenticated_system.rb @@ -0,0 +1,127 @@ +module AuthenticatedSystem + protected + # Returns true or false if the user is logged in. + # Preloads @current_user with the user model if they're logged in. + def logged_in? + !!current_user + end + + # Accesses the current user from the session. + # Future calls avoid the database because nil is not equal to false. + def current_user + @current_user ||= login_from_session unless @current_user == false + end + + # Store the given user id in the session. + def current_user=(new_user) + session[:user_id] = new_user ? new_user.id : nil + @current_user = new_user || false + end + + # Check if the user is authorized + # + # Override this method in your controllers if you want to restrict access + # to only a few actions or if you want to check if the user + # has the correct rights. + # + # Example: + # + # # only allow nonbobs + # def authorized? + # current_user.login != "bob" + # end + # + def authorized?(action = action_name, resource = nil) + logged_in? + end + + # Filter method to enforce a login requirement. + # + # To require logins for all actions, use this in your controllers: + # + # before_filter :login_required + # + # To require logins for specific actions, use this in your controllers: + # + # before_filter :login_required, :only => [ :edit, :update ] + # + # To skip this in a subclassed controller: + # + # skip_before_filter :login_required + # + def login_required + authorized? || access_denied + end + + # Redirect as appropriate when an access request fails. + # + # The default action is to redirect to the login screen. + # + # Override this method in your controllers if you want to have special + # behavior in case the user is not authorized + # to access the requested action. For example, a popup window might + # simply close itself. + def access_denied + respond_to do |format| + format.html do + store_location + redirect_to new_session_path + end + end + end + + # Store the URI of the current request in the session. + # + # We can return to this location by calling #redirect_back_or_default. + def store_location + session[:return_to] = request.request_uri + end + + # Redirect to the URI stored by the most recent store_location call or + # to the passed default. Set an appropriately modified + # after_filter :store_location, :only => [:index, :new, :show, :edit] + # for any controller you want to be bounce-backable. + def redirect_back_or_default(default) + redirect_to(session[:return_to] || default) + session[:return_to] = nil + end + + # Inclusion hook to make #current_user and #logged_in? + # available as ActionView helper methods. + def self.included(base) + base.send :helper_method, :current_user, :logged_in?, :authorized? if base.respond_to? :helper_method + end + + # + # Login + # + + # Called from #current_user. First attempt to login by the user id stored in the session. + def login_from_session + self.current_user = User.find_by_id(session[:user_id]) if session[:user_id] + end + + # + # Logout + # + + # This is ususally what you want; resetting the session willy-nilly wreaks + # havoc with forgery protection, and is only strictly necessary on login. + # However, **all session state variables should be unset here**. + def logout_keeping_session! + # Kill server-side auth cookie + @current_user.forget_me if @current_user.is_a? User + @current_user = false # not logged in, and don't do it for me + kill_remember_cookie! # Kill client-side auth cookie + session[:user_id] = nil # keeps the session but kill our variable + # explicitly kill any other session variables you set + end + + # The session should only be reset at the tail end of a form POST -- + # otherwise the request forgery protection fails. It's only really necessary + # when you cross quarantine (logged-out to logged-in). + def logout_killing_session! + logout_keeping_session! + reset_session + end +end diff --git a/lib/authenticated_test_helper.rb b/lib/authenticated_test_helper.rb new file mode 100644 index 0000000..c0ec5f4 --- /dev/null +++ b/lib/authenticated_test_helper.rb @@ -0,0 +1,6 @@ +module AuthenticatedTestHelper + # Sets the current user in the session from the user fixtures. + def login_as(user) + @request.session[:user_id] = user ? users(user).id : nil + end +end diff --git a/lib/authentication.rb b/lib/authentication.rb new file mode 100644 index 0000000..a936589 --- /dev/null +++ b/lib/authentication.rb @@ -0,0 +1,103 @@ +module Authentication + mattr_accessor :login_regex, :bad_login_message, + :name_regex, :bad_name_message, + :email_name_regex, :domain_head_regex, :domain_tld_regex, :email_regex, :bad_email_message + + self.login_regex = /\A\w[\w\.\-_@]+\z/ # ASCII, strict + # self.login_regex = /\A[[:alnum:]][[:alnum:]\.\-_@]+\z/ # Unicode, strict + # self.login_regex = /\A[^[:cntrl:]\\<>\/&]*\z/ # Unicode, permissive + + self.bad_login_message = "use only letters, numbers, and .-_@ please.".freeze + + self.name_regex = /\A[^[:cntrl:]\\<>\/&]*\z/ # Unicode, permissive + self.bad_name_message = "avoid non-printing characters and \\><&/ please.".freeze + + self.email_name_regex = '[\w\.%\+\-]+'.freeze + self.domain_head_regex = '(?:[A-Z0-9\-]+\.)+'.freeze + self.domain_tld_regex = '(?:[A-Z]{2}|com|org|net|edu|gov|mil|biz|info|mobi|name|aero|jobs|museum)'.freeze + self.email_regex = /\A#{email_name_regex}@#{domain_head_regex}#{domain_tld_regex}\z/i + self.bad_email_message = "should look like an email address.".freeze + + def self.included(recipient) + recipient.extend(ModelClassMethods) + recipient.class_eval do + include ModelInstanceMethods + end + end + + module ModelClassMethods + def secure_digest(*args) + Digest::SHA1.hexdigest(args.flatten.join('--')) + end + + def make_token + secure_digest(Time.now, (1..10).map{ rand.to_s }) + end + end # class methods + + module ModelInstanceMethods + end # instance methods + + module ByPassword + # Stuff directives into including module + def self.included(recipient) + recipient.extend(ModelClassMethods) + recipient.class_eval do + include ModelInstanceMethods + + # Virtual attribute for the unencrypted password + attr_accessor :password + validates_presence_of :password, :if => :password_required? + validates_presence_of :password_confirmation, :if => :password_required? + validates_confirmation_of :password, :if => :password_required? + validates_length_of :password, :within => 6..40, :if => :password_required? + before_save :encrypt_password + end + end # #included directives + + # + # Class Methods + # + module ModelClassMethods + # This provides a modest increased defense against a dictionary attack if + # your db were ever compromised, but will invalidate existing passwords. + # See the README and the file config/initializers/site_keys.rb + # + # It may not be obvious, but if you set REST_AUTH_SITE_KEY to nil and + # REST_AUTH_DIGEST_STRETCHES to 1 you'll have backwards compatibility with + # older versions of restful-authentication. + def password_digest(password, salt) + digest = REST_AUTH_SITE_KEY + REST_AUTH_DIGEST_STRETCHES.times do + digest = secure_digest(digest, salt, password, REST_AUTH_SITE_KEY) + end + digest + end + end # class methods + + # + # Instance Methods + # + module ModelInstanceMethods + + # Encrypts the password with the user salt + def encrypt(password) + self.class.password_digest(password, salt) + end + + def authenticated?(password) + crypted_password == encrypt(password) + end + + # before filter + def encrypt_password + return if password.blank? + self.salt = self.class.make_token if new_record? + self.crypted_password = encrypt(password) + end + def password_required? + crypted_password.blank? || !password.blank? + end + end # instance methods + end +end \ No newline at end of file -- cgit v1.3