dionysus 0.3.0 → 0.3.1

data/Rakefile

@@ -44,3 +44,5 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*', 'LICENSE', 'VERSION')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+task :clobber => [:clobber_rcov, :clobber_rdoc]

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.1

data/dionysus.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dionysus}
-  s.version = "0.3.0"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Travis D. Warlick, Jr."]
-  s.date = %q{2010-04-02}
+  s.date = %q{2010-04-04}
   s.email = %q{warlickt@operissystems.com}
   s.extra_rdoc_files = [
     "LICENSE",

data/lib/dionysus/digest.rb

@@ -65,21 +65,15 @@ module Digest
   ##
   # The lengths of the registered digests in the given encoding.
   def self.digest_lengths( encoding = :binary )
-    if encoding.is_a?(Symbol)
-      bits_per_char = case encoding
-        when :binary then 8
-        when :base64 then 6
-        when :hex, :hexidecimal then 4
-        when :bit then 1
-        else raise ArgumentError, "Invalid encoding"
-      end
+    if encoding == :bit or encoding == 1
+      _digest_lengths(1)
+    elsif encoding.is_a?(Symbol) and String::ENCODING_BITS_PER_CHAR[encoding]
+      _digest_lengths(String::ENCODING_BITS_PER_CHAR[encoding])
     elsif encoding.is_a?(Integer) and encoding > 0
-      bits_per_char = encoding
+      _digest_lengths(encoding)
     else
       raise ArgumentError, "Invalid encoding"
     end
-    
-    Hash[ self.digests.collect { |dig, info| [dig, info[:bit_length] / bits_per_char] } ]
   end
   
   ##
@@ -89,12 +83,48 @@ module Digest
   #
   #     Digest.digest(:sha512, 'foobar') #=> binary digest
   #     Digest.digest(Digest::SHA512, 'foobar') #=> binary digest
-  def self.digest( sym_or_klass, str )
-    if sym_or_klass.is_a?(Class)
-      sym_or_klass
-    else
-      Digest.const_get(sym_or_klass.to_s.upcase)
-    end.digest(str)
+  def self.digest( sym, str )
+    Digest.const_get(sym.to_s.upcase).digest(str)
+  end
+  
+  ##
+  # Detect the digest of the string.  Returns nil if the digest cannot be 
+  # determined.
+  #
+  # Example:
+  #     Digest.detect_digest("wxeCFXPVXePFcpwuFDjonyn1G/w=", :base64) #=> :sha1
+  #     Digest.detect_digest("foobar", :hex) #=> nil
+  def self.detect_digest( string, encoding = :binary )
+    string = string.strip unless encoding == :binary
+    dig = self.digest_lengths(encoding).invert[string.length]
+    dig = :sha256 if dig == :sha2
+    dig
+  end
+  
+  ##
+  # Detect the digest of the string.  Returns nil if the digest cannot be 
+  # determined.
+  #
+  # Example:
+  #     Digest.detect_digest!("wxeCFXPVXePFcpwuFDjonyn1G/w=", :base64) #=> :sha1
+  #     Digest.detect_digest!("foobar", :hex) #=> RuntimeError
+  def self.detect_digest!( string, encoding = :binary )
+    self.detect_digest(string, encoding) or raise("Unknown digest")
+  end
+  
+  private
+  
+  def self._digest_lengths( bits_per_char ) # :nodoc:
+    padding_factor = (bits_per_char.lcm(8) / bits_per_char)
+    
+    returning result={} do
+      self.digests.each do |dig, info|
+        result[dig] = len = info[:bit_length] / bits_per_char
+        if (t_ = len % padding_factor) != 0
+          result[dig] = len + (padding_factor - t_)
+        end
+      end
+    end
   end
 end
 

data/lib/dionysus/security/password_salt.rb

@@ -77,19 +77,11 @@ class PasswordSalt
   #             Default: 8
   def initialize( *args )
     options = args.extract_options!
-    if args[0].nil? or args[0] == :new or args[0].is_a?(String)
-      self.string = args[0] || :new
-    end
     
-    if args[0].is_a?(Symbol) and args[0] != :new
-      self.placement = args[0]
-    elsif args[1].is_a?(Symbol)
-      self.placement = args[1]
-    else
-      self.placement = DEFAULT_PLACEMENT
-    end
+    self.string = args.detect { |val| val.is_a?(String) or val == :new }
+    self.placement = args.detect { |val| PLACEMENTS.include?(val) } || DEFAULT_PLACEMENT
     
-    if self.string == :new
+    if self.string == :new or self.string.nil?
       self.string = self.class.generate(options[:length] || DEFAULT_LENGTH)
     end
   end

data/lib/dionysus/security/string.rb

@@ -53,22 +53,33 @@ class String
   def method_missing( method, *args )
     super if block_given?
     
-    begin
-      return self.digest(method, *args)
-    rescue NameError
+    if Digest.available_digests.include?(method)
+      self.digest(method, *args)
+    else
+      super
     end
-    super
   end
   
   ##
-  # Detect the digest of the string
+  # Detect the digest of the string.  Returns nil if the digest cannot be 
+  # determined.
+  #
+  # Example:
+  #     "wxeCFXPVXePFcpwuFDjonyn1G/w=".detect_digest(:base64) #=> :sha1
+  #     "foobar".detect_digest(:hex) #=> nil
   def detect_digest( encoding )
-    self.class.available_digests.each do |dig|
-      if ''.digest(dig, :encoding => encoding).length == self.length
-        return dig
-      end
-    end
-    raise "Unknown digest."
+    Digest.detect_digest(self, encoding)
+  end
+  
+  ##
+  # Detect the digest of the string.  Raises "Unknown digest" if the digest
+  # cannot be determined.
+  #
+  # Example:
+  #     "wxeCFXPVXePFcpwuFDjonyn1G/w=".detect_digest!(:base64) #=> :sha1
+  #     "foobar".detect_digest!(:hex) #=> RuntimeError
+  def detect_digest!( encoding )
+    Digest.detect_digest!(self, encoding)
   end
   
   private

data/lib/dionysus/string.rb

@@ -8,6 +8,7 @@ require 'active_support/base64'
 class String
   HEX_REGEXP = /^[a-f0-9]+$/
   BASE64_REGEXP = /^[A-Za-z0-9\+\/\=]+$/
+  ENCODING_BITS_PER_CHAR = {:binary => 8, :base64 => 6, :hex => 4, :hexidecimal => 4}
   
   ##
   # Encode the Base64 (without newlines)

data/spec/digest_spec.rb

@@ -3,6 +3,8 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'dionysus/digest'
 
 describe Digest do
+  DIGESTS = { :md5 => 128, :sha1 => 160, :sha2 => 256, 
+              :sha256 => 256, :sha384 => 384, :sha512 => 512 }
   it 'should have the default available digests' do
     Digest.available_digests.length.should == Digest::DEFAULT_DIGESTS.length
     Digest::DEFAULT_DIGESTS.each do |dig|
@@ -87,8 +89,7 @@ describe Digest do
   end
   
   describe 'digest lengths' do
-    { :md5 => 128, :sha1 => 160, :sha2 => 256, 
-      :sha256 => 256, :sha384 => 384, :sha512 => 512 }.each do |dig, bits|
+    DIGESTS.each do |dig, bits|
         it "should have binary length for #{dig}" do
           Digest.digest_lengths[dig].should == bits / 8
           Digest.digest_lengths(:binary)[dig].should == bits / 8
@@ -102,8 +103,10 @@ describe Digest do
         end
         
         it "should have base64 length for #{dig}" do
-          Digest.digest_lengths(:base64)[dig].should == bits / 6
-          Digest.digest_lengths(6)[dig].should == bits / 6
+          len = bits / 6
+          expected = (len % 4 == 0 ? len : len + (4 - len % 4))
+          Digest.digest_lengths(:base64)[dig].should == expected
+          Digest.digest_lengths(6)[dig].should == expected
         end
 
         it "should have bit length for #{dig}" do
@@ -112,14 +115,69 @@ describe Digest do
         end
         
         it "should have arbitrary length for #{dig}" do
-          Digest.digest_lengths(7)[dig].should == bits / 7
+          len = bits / 7
+          Digest.digest_lengths(7)[dig].should == len + (8 - len % 8)
         end
     end
     
     it 'should reject bit length requests for < 0' do
-      lambda { Digest.digest_lengths(0).should    raise_error(ArgumentError, 'Invalid encoding') }
-      lambda { Digest.digest_lengths(-1).should   raise_error(ArgumentError, 'Invalid encoding') }
-      lambda { Digest.digest_lengths(-100).should raise_error(ArgumentError, 'Invalid encoding') }
+      lambda { Digest.digest_lengths(0) }.should    raise_error(ArgumentError, 'Invalid encoding')
+      lambda { Digest.digest_lengths(-1) }.should   raise_error(ArgumentError, 'Invalid encoding')
+      lambda { Digest.digest_lengths(-100) }.should raise_error(ArgumentError, 'Invalid encoding')
+    end
+    
+    it 'should reject bit length requests for unknown encodings' do
+      lambda { Digest.digest_lengths(:my_digest) }.should raise_error(ArgumentError, 'Invalid encoding')
+    end
+  end
+  
+  describe "digest helper" do
+    DIGESTS.each do |dig, bits|
+      it "should run the digest for #{dig}" do
+        Digest.digest(dig, 'foobar').length.should == bits / 8
+      end
+      
+      it "should still have working original digest methods" do
+        "Digest::#{dig.to_s.upcase}".constantize.digest('foobar').length.should == bits / 8
+      end
+    end
+    
+    it "should fail invalid digest" do
+      lambda { Digest.digest(:my_digest, 'foobar') }.should raise_error(LoadError)
+    end
+  end
+  
+  describe "detection" do
+    DIGESTS.each do |dig, bits|
+      it "should detect #{dig} in binary" do
+        str = Digest.digest(dig, 'foobar')
+        Digest.detect_digest(str).should == (dig == :sha2 ? :sha256 : dig)
+        Digest.detect_digest(str, :binary).should == (dig == :sha2 ? :sha256 : dig)
+        Digest.detect_digest!(str).should == (dig == :sha2 ? :sha256 : dig)
+        Digest.detect_digest!(str, :binary).should == (dig == :sha2 ? :sha256 : dig)
+      end
+      
+      it "should detect #{dig} in base64" do
+        str = Digest.digest(dig, 'foobar').encode64s
+        Digest.detect_digest(str, :base64).should == (dig == :sha2 ? :sha256 : dig)
+        Digest.detect_digest!(str, :base64).should == (dig == :sha2 ? :sha256 : dig)
+      end
+      
+      it "should detect #{dig} in hexidecimal" do
+        str = Digest.digest(dig, 'foobar').encode_hexidecimal
+        Digest.detect_digest(str, :hex).should == (dig == :sha2 ? :sha256 : dig)
+        Digest.detect_digest(str, :hexidecimal).should == (dig == :sha2 ? :sha256 : dig)
+        Digest.detect_digest!(str, :hex).should == (dig == :sha2 ? :sha256 : dig)
+        Digest.detect_digest!(str, :hexidecimal).should == (dig == :sha2 ? :sha256 : dig)
+      end
+    end
+    
+    it "should return nil on unknown digest" do
+      Digest.detect_digest('blah').should be_nil
+    end
+    
+    it "should fail on unknown digest with !" do
+      lambda { Digest.detect_digest!('blah') }.should raise_error(RuntimeError, "Unknown digest")
     end
   end
 end

data/spec/password_salt_spec.rb

@@ -93,6 +93,10 @@ describe PasswordSalt do
         salt.should_not match(/\A[A-Za-z0-9\+\/]{100}\Z/)
       end
     end
+    
+    it "should raise an error with an invalid format" do
+      lambda { PasswordSalt.generate(10, :foobar) }.should raise_error(ArgumentError, "Invalid format: foobar")
+    end
   end
   
   describe "after placement" do
@@ -110,6 +114,12 @@ describe PasswordSalt do
       salt = PasswordSalt.new(@salt, :after)
       salt.salt_password(@password).should == @password+@salt
     end
+    
+    it "should raise an error with a bad placement" do
+      salt = PasswordSalt.new(@salt)
+      salt.instance_variable_set('@placement', :foobar)
+      lambda { salt.salt_password(@password) }.should raise_error(RuntimeError, "Invalid salt placement: foobar")
+    end
   end
   
   describe "before placement" do

data/spec/string_security_spec.rb

@@ -179,4 +179,26 @@ describe String do
     "abcde\240z405".digest(:md5, :encoding => :binary).should == digest
     "abcde\240z405".md5(:encoding => :binary).should == digest
   end
+  
+  it "should fallback to super method missing with unavailable digest" do
+    lambda { "abcde\240z405".my_digest }.should raise_error(NoMethodError)
+  end
+  
+  it "should raise an error with invalid encoding" do
+    lambda { "abcde\240z405".md5(:encoding => :foobar) }.should raise_error(ArgumentError, 'Invalid encoding: foobar')
+  end
+  
+  describe "digest detection" do
+    it "should defer to Digest" do
+      str = "abcde\240z405"
+      Digest.should_receive(:detect_digest).with(str, :binary)
+      str.detect_digest(:binary)
+    end
+    
+    it "should defer to Digest" do
+      str = "abcde\240z405"
+      Digest.should_receive(:detect_digest!).with(str, :binary)
+      str.detect_digest!(:binary)
+    end
+  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Travis D. Warlick, Jr.
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-02 00:00:00 -05:00
+date: 2010-04-04 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency