pipa-authmagic 0.1 → 0.1.1

data/lib/authmagic/exceptions.rb

@@ -27,9 +27,5 @@ module Authmagic
     def initialize(msg = nil)
       super(msg || 'access denied')
     end
-
-    def handle_response!(response)
-      response.status = "403 #{self}"
-    end
   end
 end

data/lib/authmagic/rails.rb

@@ -5,5 +5,6 @@ class << ActionController::Base
     context = Authmagic::Context.new(modules, :application_controller => self, &block)
     metaclass.send(:define_method, :security_context) { context }
     define_method(:security_context) { self.class.security_context }
+		private :security_context
   end
 end

data/lib/authmagic/rails/modules/login_password.rb

@@ -18,46 +18,31 @@ module Authmagic
       when :ci, :case_insensitive then false
       else raise 'bad :compare value'
       end
-      password = cfg.fetch(:password_field, :password)
-      password_set = :"#{password}="
-      password_valid = :"#{password}_valid?"
-      password_hash = cfg.fetch(:password_hash_field, :"#{password}_hash")
+      password_get = cfg.fetch(:password_field, :password)
+      password_set, password_var = :"#{password_get}=", :"@#{password_get}"
+      password_valid = :"#{password_get}_valid?"
+      password_hash = cfg.fetch(:password_hash_field, :"#{password_get}_hash")
       password_hash_set = :"#{password_hash}="
-      salt = cfg.fetch(:password_salt_field, :"#{password}_salt")
-      salt_set = :"#{salt}="
-      encryptor = :"encrypt_#{password}"
-      generate_salt = :"generate_#{salt}"
+      salt_get = cfg.fetch(:password_salt_field, :"#{password_get}_salt")
+      salt_set = :"#{salt_get}="
+      encryptor = :"encrypt_#{password_get}"
+      generate_salt = :"generate_#{salt_get}"
 
       digest = cfg.fetch(:digest) do
         require 'digest/sha2'
         Digest::SHA512
       end
       digest = "Digest::#{digest.camelize}".constantize unless digest.is_a?(Class)
-      stretches = cfg.fetch(:stretches, 20)
+      stretches = cfg.fetch(:stretches, 100)
       salt_length = cfg.fetch(:salt_length, 64)
 
       cols = principal.columns_hash
-      col_pass_hash, col_salt = cols[password_hash.to_s], cols[salt.to_s]
+      col_pass_hash, col_salt = cols[password_hash.to_s], cols[salt_get.to_s]
       raise "missing required attribute #{password_hash} from #{principal} model" unless col_pass_hash
-      raise "missing required attribute #{salt} from #{principal} model" unless col_salt
+      raise "missing required attribute #{salt_get} from #{principal} model" unless col_salt
 
-      digest_method = case col_pass_hash.type
-      when :string
-        :hexdigest
-      when :binary
-        :digest
-      else
-        raise "unsupported type #{col_pass_hash.type} for #{password_hash}"
-      end
-
-      secran_salt = case col_salt.type
-      when :string
-        :hex
-      when :binary
-        :random_bytes
-      else
-        raise "unsupported type #{col_salt.type} for #{salt}"
-      end
+      hexdigest = col_pass_hash.type != :binary
+      secran_salt = col_salt.type == :binary ? :random_bytes : :hex
 
       principal.class_eval do
         self.class.send(:define_method, :authenticate) do |options|
@@ -66,15 +51,15 @@ module Authmagic
             ["lower(#{connection.quote_column_name(login)}) = lower(?)", options[login]]
           returning first(:conditions => conditions) do |p|
             raise AccountNotFound unless p
-            raise BadPassword unless p.send(password_valid, options[password])
+            raise BadPassword unless p.send(password_valid, options[password_get])
           end
         end
 
-        attr_reader password
+        attr_reader password_get
 
         define_method password_set do |passw|
-          instance_variable_set("@#{password}", passw)
-          send(salt_set, send(generate_salt))
+          instance_variable_set(password_var, passw)
+          send(generate_salt)
           send(password_hash_set, send(encryptor, passw))
         end
 
@@ -83,13 +68,13 @@ module Authmagic
         end
 
         define_method encryptor do |plaintext|
-          hash = (digest.new << (send(salt) || '') << plaintext).send(digest_method)
-          stretches.times { hash = (digest.new << hash).send(digest_method) }
-          hash
+          dg, salt, hash = digest.new, send(salt_get), ''
+					stretches.times { hash = (dg << salt << plaintext << hash).digest! }
+          hexdigest ? Digest.hexencode(hash) : hash
         end
 
         define_method generate_salt do
-          ActiveSupport::SecureRandom.send(secran_salt, salt_length)
+          send(salt_set, ActiveSupport::SecureRandom.send(secran_salt, salt_length))
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pipa-authmagic
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: 0.1.1
 platform: ruby
 authors: 
 - Igor Gunko
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-21 00:00:00 -08:00
+date: 2009-01-26 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency