railsware-authlogic 2.1.6.1

data/lib/authlogic/authenticates_many/association.rb

@@ -0,0 +1,42 @@
+module Authlogic
+  module AuthenticatesMany
+    # An object of this class is used as a proxy for the authenticates_many relationship. It basically allows you to "save" scope details
+    # and call them on an object, which allows you to do the following:
+    #
+    #   @account.user_sessions.new
+    #   @account.user_sessions.find
+    #   # ... etc
+    #
+    # You can call all of the class level methods off of an object with a saved scope, so that calling the above methods scopes the user
+    # sessions down to that specific account. To implement this via ActiveRecord do something like:
+    #
+    #   class User < ActiveRecord::Base
+    #     authenticates_many :user_sessions
+    #   end
+    class Association
+      attr_accessor :klass, :find_options, :id
+      
+      def initialize(klass, find_options, id)
+        self.klass = klass
+        self.find_options = find_options
+        self.id = id
+      end
+      
+      [:create, :create!, :find, :new].each do |method|
+        class_eval <<-"end_eval", __FILE__, __LINE__
+          def #{method}(*args)
+            klass.with_scope(scope_options) do
+              klass.#{method}(*args)
+            end
+          end
+        end_eval
+      end
+      alias_method :build, :new
+    
+      private
+        def scope_options
+          {:find_options => find_options, :id => id}
+        end
+    end
+  end
+end

data/lib/authlogic/authenticates_many/base.rb

@@ -0,0 +1,55 @@
+module Authlogic
+  # This allows you to scope your authentication. For example, let's say all users belong to an account, you want to make sure only users
+  # that belong to that account can actually login into that account. Simple, just do:
+  #
+  #   class Account < ActiveRecord::Base
+  #     authenticates_many :user_sessions
+  #   end
+  #
+  # Now you can scope sessions just like everything else in ActiveRecord:
+  #
+  #   @account.user_sessions.new(*args)
+  #   @account.user_sessions.create(*args)
+  #   @account.user_sessions.find(*args)
+  #   # ... etc
+  #
+  # Checkout the authenticates_many method for a list of options.
+  # You may also want to checkout Authlogic::ActsAsAuthentic::Scope to scope your model.
+  module AuthenticatesMany
+    module Base
+      # Allows you set essentially set up a relationship with your sessions. See module definition above for more details.
+      #
+      # === Options
+      #
+      # * <tt>session_class:</tt> default: "#{name}Session",
+      #   This is the related session class.
+      #   
+      # * <tt>relationship_name:</tt> default: options[:session_class].klass_name.underscore.pluralize,
+      #   This is the name of the relationship you want to use to scope everything. For example an Account has many Users. There should be a relationship
+      #   called :users that you defined with a has_many. The reason we use the relationship is so you don't have to repeat yourself. The relatonship
+      #   could have all kinds of custom options. So instead of repeating yourself we essentially use the scope that the relationship creates.
+      #
+      # * <tt>find_options:</tt> default: nil,
+      #   By default the find options are created from the relationship you specify with :relationship_name. But if you want to override this and
+      #   manually specify find_options you can do it here. Specify options just as you would in ActiveRecord::Base.find.
+      #
+      # * <tt>scope_cookies:</tt> default: false
+      #   By the nature of cookies they scope theirself if you are using subdomains to access accounts. If you aren't using subdomains you need to have
+      #   separate cookies for each account, assuming a user is logging into mroe than one account. Authlogic can take care of this for you by
+      #   prefixing the name of the cookie and sessin with the model id. You just need to tell Authlogic to do this by passing this option.
+      def authenticates_many(name, options = {})
+        options[:session_class] ||= name.to_s.classify.constantize
+        options[:relationship_name] ||= options[:session_class].klass_name.underscore.pluralize
+        class_eval <<-"end_eval", __FILE__, __LINE__
+          def #{name}
+            find_options = #{options[:find_options].inspect} || #{options[:relationship_name]}.scope(:find)
+            find_options.delete_if { |key, value| ![:conditions, :include, :joins].include?(key.to_sym) || value.nil? }
+            @#{name} ||= Authlogic::AuthenticatesMany::Association.new(#{options[:session_class]}, find_options, #{options[:scope_cookies] ? "self.class.model_name.underscore + '_' + self.send(self.class.primary_key).to_s" : "nil"})
+          end
+        end_eval
+      end
+    end
+    
+    ::ActiveRecord::Base.extend(Base) if defined?(::ActiveRecord)
+  end
+end

data/lib/authlogic/controller_adapters/abstract_adapter.rb

@@ -0,0 +1,67 @@
+module Authlogic
+  module ControllerAdapters # :nodoc:
+    # Allows you to use Authlogic in any framework you want, not just rails. See the RailsAdapter or MerbAdapter
+    # for an example of how to adapt Authlogic to work with your framework.
+    class AbstractAdapter
+      attr_accessor :controller
+
+      def initialize(controller)
+        self.controller = controller
+      end
+      
+      def authenticate_with_http_basic(&block)
+        @auth = Rack::Auth::Basic::Request.new(controller.request.env)
+        if @auth.provided? and @auth.basic?
+          block.call(*@auth.credentials)
+        else
+          false
+        end
+      end
+      
+      def cookies
+        controller.cookies
+      end
+      
+      def cookie_domain
+        raise NotImplementedError.new("The cookie_domain method has not been implemented by the controller adapter")
+      end
+
+      def params
+        controller.params
+      end
+
+      def request
+        controller.request
+      end
+
+      def request_content_type
+        request.content_type
+      end
+
+      def session
+        controller.session
+      end
+      
+      def responds_to_single_access_allowed?
+        controller.respond_to?(:single_access_allowed?, true)
+      end
+      
+      def single_access_allowed?
+        controller.send(:single_access_allowed?)
+      end
+      
+      def responds_to_last_request_update_allowed?
+        controller.respond_to?(:last_request_update_allowed?, true)
+      end
+      
+      def last_request_update_allowed?
+        controller.send(:last_request_update_allowed?)
+      end
+      
+      private
+        def method_missing(id, *args, &block)
+          controller.send(id, *args, &block)
+        end
+    end
+  end
+end

data/lib/authlogic/controller_adapters/merb_adapter.rb

@@ -0,0 +1,30 @@
+module Authlogic
+  module ControllerAdapters
+    # Adapts authlogic to work with merb. The point is to close the gap between what authlogic expects and what the merb controller object
+    # provides. Similar to how ActiveRecord has an adapter for MySQL, PostgreSQL, SQLite, etc.
+    class MerbAdapter < AbstractAdapter
+      # Lets Authlogic know about the controller object via a before filter, AKA "activates" authlogic.
+      module MerbImplementation
+        def self.included(klass) # :nodoc:
+          klass.before :activate_authlogic
+        end
+        
+        def cookie_domain
+          Merb::Config[:session_cookie_domain]
+        end
+
+        private
+          def activate_authlogic
+            Authlogic::Session::Base.controller = MerbAdapter.new(self)
+          end
+      end
+    end
+  end
+end
+ 
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+  Merb::BootLoader.before_app_loads do
+    Merb::Controller.send(:include, Authlogic::ControllerAdapters::MerbAdapter::MerbImplementation)
+  end
+end

data/lib/authlogic/controller_adapters/rails_adapter.rb

@@ -0,0 +1,48 @@
+module Authlogic
+  module ControllerAdapters
+    # Adapts authlogic to work with rails. The point is to close the gap between what authlogic expects and what the rails controller object
+    # provides. Similar to how ActiveRecord has an adapter for MySQL, PostgreSQL, SQLite, etc.
+    class RailsAdapter < AbstractAdapter
+      class AuthlogicLoadedTooLateError < StandardError; end
+      
+      def authenticate_with_http_basic(&block)
+        controller.authenticate_with_http_basic(&block)
+      end
+      
+      def cookies
+        controller.send(:cookies)
+      end
+      
+      def cookie_domain
+        @cookie_domain_key ||= Rails::VERSION::STRING >= '2.3' ? :domain : :session_domain
+        controller.request.session_options[@cookie_domain_key]
+      end
+      
+      def request_content_type
+        request.format.to_s
+      end
+      
+      # Lets Authlogic know about the controller object via a before filter, AKA "activates" authlogic.
+      module RailsImplementation
+        def self.included(klass) # :nodoc:
+          if defined?(::ApplicationController)
+            raise AuthlogicLoadedTooLateError.new("Authlogic is trying to prepend a before_filter in ActionController::Base to active itself" +
+              ", the problem is that ApplicationController has already been loaded meaning the before_filter won't get copied into your" +
+              " application. Generally this is due to another gem or plugin requiring your ApplicationController prematurely, such as" +
+              " the resource_controller plugin. The solution is to require Authlogic before these other gems / plugins. Please require" +
+              " authlogic first to get rid of this error.")
+          end
+          
+          klass.prepend_before_filter :activate_authlogic
+        end
+        
+        private
+          def activate_authlogic
+            Authlogic::Session::Base.controller = RailsAdapter.new(self)
+          end
+      end
+    end
+  end
+end
+
+ActionController::Base.send(:include, Authlogic::ControllerAdapters::RailsAdapter::RailsImplementation)

data/lib/authlogic/controller_adapters/sinatra_adapter.rb

@@ -0,0 +1,61 @@
+# Authlogic bridge for Sinatra
+module Authlogic
+  module ControllerAdapters
+    module SinatraAdapter
+      class Cookies
+        attr_reader :request, :response
+
+        def initialize(request, response)
+          @request = request
+          @response = response
+        end
+
+        def delete(key, options = {})
+          @request.cookies.delete(key)
+        end
+
+        def []=(key, options)
+          @response.set_cookie(key, options)
+        end
+
+        def method_missing(meth, *args, &block)
+          @request.cookies.send(meth, *args, &block)
+        end
+      end
+
+      class Controller
+        attr_reader :request, :response, :cookies
+
+        def initialize(request, response)
+          @request = request
+          @cookies = Cookies.new(request, response)
+        end
+
+        def session
+          env['rack.session']
+        end
+
+        def method_missing(meth, *args, &block)
+          @request.send meth, *args, &block
+        end
+      end
+
+      class Adapter < AbstractAdapter
+        def cookie_domain
+          env['SERVER_NAME']
+        end
+
+        module Implementation
+          def self.included(klass)
+            klass.send :before do
+              controller = Controller.new(request, response)
+              Authlogic::Session::Base.controller = Adapter.new(controller)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Sinatra::Request.send(:include, Authlogic::ControllerAdapters::SinatraAdapter::Adapter::Implementation)

data/lib/authlogic/crypto_providers/aes256.rb

@@ -0,0 +1,43 @@
+require "openssl"
+
+module Authlogic
+  module CryptoProviders
+    # This encryption method is reversible if you have the supplied key. So in order to use this encryption method you must supply it with a key first.
+    # In an initializer, or before your application initializes, you should do the following:
+    #
+    #   Authlogic::CryptoProviders::AES256.key = "my really long and unique key, preferrably a bunch of random characters"
+    #
+    # My final comment is that this is a strong encryption method, but its main weakness is that its reversible. If you do not need to reverse the hash
+    # then you should consider Sha512 or BCrypt instead.
+    #
+    # Keep your key in a safe place, some even say the key should be stored on a separate server.
+    # This won't hurt performance because the only time it will try and access the key on the separate server is during initialization, which only
+    # happens once. The reasoning behind this is if someone does compromise your server they won't have the key also. Basically, you don't want to
+    # store the key with the lock.
+    class AES256
+      class << self
+        attr_writer :key
+    
+        def encrypt(*tokens)
+          aes.encrypt
+          aes.key = @key
+          [aes.update(tokens.join) + aes.final].pack("m").chomp
+        end
+    
+        def matches?(crypted, *tokens)
+          aes.decrypt
+          aes.key = @key
+          (aes.update(crypted.unpack("m").first) + aes.final) == tokens.join
+        rescue OpenSSL::CipherError
+          false
+        end
+    
+        private
+          def aes
+            raise ArgumentError.new("You must provide a key like #{name}.key = my_key before using the #{name}") if @key.blank?
+            @aes ||= OpenSSL::Cipher::Cipher.new("AES-256-ECB")
+          end
+      end
+    end
+  end
+end

data/lib/authlogic/crypto_providers/bcrypt.rb

@@ -0,0 +1,90 @@
+begin
+  require "bcrypt"
+rescue LoadError
+  "sudo gem install bcrypt-ruby"
+end
+
+module Authlogic
+  module CryptoProviders
+    # For most apps Sha512 is plenty secure, but if you are building an app that stores nuclear launch codes you might want to consier BCrypt. This is an extremely
+    # secure hashing algorithm, mainly because it is slow. A brute force attack on a BCrypt encrypted password would take much longer than a brute force attack on a
+    # password encrypted with a Sha algorithm. Keep in mind you are sacrificing performance by using this, generating a password takes exponentially longer than any
+    # of the Sha algorithms. I did some benchmarking to save you some time with your decision:
+    #
+    #   require "bcrypt"
+    #   require "digest"
+    #   require "benchmark"
+    #
+    #   Benchmark.bm(18) do |x|
+    #     x.report("BCrypt (cost = 10:") { 100.times { BCrypt::Password.create("mypass", :cost => 10) } }
+    #     x.report("BCrypt (cost = 2:") { 100.times { BCrypt::Password.create("mypass", :cost => 2) } }
+    #     x.report("Sha512:") { 100.times { Digest::SHA512.hexdigest("mypass") } }
+    #     x.report("Sha1:") { 100.times { Digest::SHA1.hexdigest("mypass") } }
+    #   end
+    #
+    #                           user     system      total        real
+    #   BCrypt (cost = 10): 10.780000   0.060000  10.840000 ( 11.100289)
+    #   BCrypt (cost = 2):  0.180000   0.000000   0.180000 (  0.181914)
+    #   Sha512:             0.000000   0.000000   0.000000 (  0.000829)
+    #   Sha1:               0.000000   0.000000   0.000000 (  0.000395)
+    #
+    # You can play around with the cost to get that perfect balance between performance and security.
+    #
+    # Decided BCrypt is for you? Just insall the bcrypt gem:
+    #
+    #   gem install bcrypt-ruby
+    #
+    # Tell acts_as_authentic to use it:
+    #
+    #   acts_as_authentic do |c|
+    #     c.crypto_provider = Authlogic::CryptoProviders::BCrypt
+    #   end
+    #
+    # You are good to go!
+    class BCrypt
+      class << self
+        # This is the :cost option for the BCrpyt library. The higher the cost the more secure it is and the longer is take the generate a hash. By default this is 10.
+        # Set this to whatever you want, play around with it to get that perfect balance between security and performance.
+        def cost
+          @cost ||= 10
+        end
+        attr_writer :cost
+        
+        # Creates a BCrypt hash for the password passed.
+        def encrypt(*tokens)
+          ::BCrypt::Password.create(join_tokens(tokens), :cost => cost)
+        end
+        
+        # Does the hash match the tokens? Uses the same tokens that were used to encrypt.
+        def matches?(hash, *tokens)
+          hash = new_from_hash(hash)
+          return false if hash.blank?
+          hash == join_tokens(tokens)
+        end
+        
+        # This method is used as a flag to tell Authlogic to "resave" the password upon a successful login, using the new cost
+        def cost_matches?(hash)
+          hash = new_from_hash(hash)
+          if hash.blank?
+            false
+          else
+            hash.cost == cost
+          end
+        end
+        
+        private
+          def join_tokens(tokens)
+            tokens.flatten.join
+          end
+          
+          def new_from_hash(hash)
+            begin
+              ::BCrypt::Password.new(hash)
+            rescue ::BCrypt::Errors::InvalidHash
+              return nil
+            end
+          end
+      end
+    end
+  end
+end