dionysus 0.2.1 → 0.3.0

data/Rakefile

@@ -9,7 +9,7 @@ begin
     gem.email = "warlickt@operissystems.com"
     gem.homepage = "http://github.com/tekwiz/dionysus"
     gem.authors = ["Travis D. Warlick, Jr."]
-    gem.add_dependency 'activesupport', '3.0.0.beta'
+    gem.add_dependency 'activesupport', '~> 3.0.0'
     gem.add_development_dependency "rspec", ">= 1.2.9"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/dionysus.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dionysus}
-  s.version = "0.2.1"
+  s.version = "0.3.0"
 
   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-03-21}
+  s.date = %q{2010-04-02}
   s.email = %q{warlickt@operissystems.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -25,11 +25,15 @@ Gem::Specification.new do |s|
      "dionysus.gemspec",
      "lib/dionysus.rb",
      "lib/dionysus/configuration.rb",
+     "lib/dionysus/digest.rb",
      "lib/dionysus/security.rb",
+     "lib/dionysus/security/password_salt.rb",
      "lib/dionysus/security/string.rb",
      "lib/dionysus/string.rb",
      "spec/configuration_spec.rb",
+     "spec/digest_spec.rb",
      "spec/dionysus_spec.rb",
+     "spec/password_salt_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
      "spec/string_security_spec.rb",
@@ -41,11 +45,13 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{A helpful set of utility classes, generators, and command-line tools.}
   s.test_files = [
-    "spec/string_spec.rb",
+    "spec/configuration_spec.rb",
+     "spec/digest_spec.rb",
+     "spec/dionysus_spec.rb",
+     "spec/password_salt_spec.rb",
      "spec/spec_helper.rb",
-     "spec/configuration_spec.rb",
      "spec/string_security_spec.rb",
-     "spec/dionysus_spec.rb"
+     "spec/string_spec.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -53,14 +59,14 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activesupport>, ["= 3.0.0.beta"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.0"])
       s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
     else
-      s.add_dependency(%q<activesupport>, ["= 3.0.0.beta"])
+      s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
       s.add_dependency(%q<rspec>, [">= 1.2.9"])
     end
   else
-    s.add_dependency(%q<activesupport>, ["= 3.0.0.beta"])
+    s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
     s.add_dependency(%q<rspec>, [">= 1.2.9"])
   end
 end

data/lib/dionysus.rb

@@ -1,5 +1,5 @@
 require 'rubygems'
-gem 'activesupport', '3.0.0.beta'
+gem 'activesupport', '~> 3.0.0'
 require 'active_support/all'
 
 ##

data/lib/dionysus/digest.rb

@@ -0,0 +1,105 @@
+require 'dionysus'
+require 'digest'
+
+##
+# Convenience methods for the Digest module.
+#
+#     require 'dionysus/digest'
+# 
+# The <tt>Digest::DEFAULT_DIGESTS</tt> are automatically registered, if they
+# exist.  You can register additional digests with Digest.register_digest.
+# The given class must give the digest with the <tt>digest(string)</tt>.
+#
+# TODO add digest detection -- by length and by proc on the digests hash
+module Digest
+  DEFAULT_DIGESTS = [:md5, :sha1, :sha2, :sha256, :sha384, :sha512]
+  @digests = {}
+  
+  ##
+  # Register a digest.  Raises an error if the interpreted class doesn't exist.
+  # It will interpret the klass as <tt>Digest::SYM</tt> if it's <tt>nil</tt>, 
+  # and it will run the <tt>digest</tt> method on the klass to determine the 
+  # digests bit length if bits is <tt>nil</tt>.
+  # 
+  # This will register <tt>:my_digest</tt> and automatically determine the bit 
+  # length by executing the class's <tt>digest</tt> method on the string 
+  # <tt>'1'</tt>:
+  #
+  #     Digest.register_digest!( :my_digest, :klass => MyDigestClass )
+  #
+  # Options:
+  # [klass]       The digest class (also can be an arbitrary object).  Default:
+  #               <tt>Digest::#{sym.to_s.upcase}</tt>
+  # [bit_length]  The bit length of the digest.  Default: calculated by 
+  #               running the digest on the string <tt>'1'</tt>.
+  # [method]      The calculation method for the digest.  Default: 
+  #               <tt>:digest</tt>
+  def self.register_digest!( sym, options = {} )
+    options = options.with_indifferent_access
+    options[:method]      ||= :digest
+    options[:klass]       ||= "Digest::#{sym.to_s.upcase}".constantize
+    options[:bit_length]  ||= options[:klass].send(options[:method], '1').length * 8
+    @digests[sym.to_sym] = options
+  end
+  
+  ##
+  # Register a digest.  Returns nil if an error occurs.
+  def self.register_digest( sym, options = {} )
+    self.register_digest!(sym, options)
+  rescue LoadError
+    nil
+  end
+  
+  ##
+  # The hash of registered digests.
+  def self.digests
+    @digests
+  end
+  
+  ##
+  # The available digests.
+  def self.available_digests
+    self.digests.keys
+  end
+  
+  ##
+  # 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
+    elsif encoding.is_a?(Integer) and encoding > 0
+      bits_per_char = encoding
+    else
+      raise ArgumentError, "Invalid encoding"
+    end
+    
+    Hash[ self.digests.collect { |dig, info| [dig, info[:bit_length] / bits_per_char] } ]
+  end
+  
+  ##
+  # Calculate the given digest of the given string.
+  #
+  # Examples:
+  #
+  #     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)
+  end
+end
+
+# Register some default digests
+Digest::DEFAULT_DIGESTS.each do |dig|
+  Digest.register_digest(dig)
+end
+

data/lib/dionysus/security.rb

@@ -1 +1,3 @@
+require 'dionysus'
 require 'dionysus/security/string'
+require 'dionysus/security/password_salt'

data/lib/dionysus/security/password_salt.rb

@@ -0,0 +1,139 @@
+require 'dionysus'
+require 'active_support/secure_random'
+
+##
+# Encapsulates a password salt.
+#
+# Examples
+#
+#     salt = PasswordSalt.new
+#     #=> generates random salt of 8 characters
+#     salt.salt_password('foobar') #=> 'foobar0PD0oKAj'
+#
+#     salt = PasswordSalt.new(:length => 20)
+#     #=> generates random salt of 20 characters
+#     salt.salt_password('foobar') #=> 'foobar7qvFpfi+3jGVFaA5TaE7'
+#
+#     salt = PasswordSalt.new('ABCDEFG', :beginning)
+#     #=> generates salt 'abcdef' with beginning placement
+#     salt.salt_password('foobar')
+#     #=> 'ABCDEFGfoobar'
+#
+#     salt = PasswordSalt.new(:split, :length => 10)
+#     #=> generates random salt of 10 characters with split placement
+#     salt.salt_password('foobar')
+#     #=> 'WyVjpfoobarjGYXJ'
+class PasswordSalt
+  PLACEMENTS = [:before, :after, :split]
+  DEFAULT_LENGTH = 8
+  DEFAULT_PLACEMENT = :after
+  
+  @@secure_random = SecureRandom
+  cattr_accessor :secure_random
+  
+  attr_accessor :string
+  attr_reader   :placement
+  
+  ##
+  # Generate a salt string of the given length (Default: 8) with the base64 
+  # character set.  Optionally, you may pass the format as <tt>:binary</tt> to generate
+  # a binary salt.
+  def self.generate( length = DEFAULT_LENGTH, format = :base64 )
+    if length < 0
+      raise ArgumentError, "Invalid length: #{length}"
+    end
+    
+    case format.to_sym
+    when :base64
+      self.secure_random.base64(length)[0...length]
+    when :binary
+      self.secure_random.random_bytes(length)
+    else
+      raise ArgumentError, "Invalid format: #{format}"
+    end
+  end
+  
+  ##
+  # Initialize a new PasswordSalt
+  #
+  # If you pass the first argument as a string, the string will be set as 
+  # the salt:
+  #     PasswordSalt.new('ABCDEFG')
+  #
+  # If the first argument is <tt>:new</tt> or is an option hash, a random salt
+  # will be generated:
+  #     PasswordSalt.new(:new)
+  #     PasswordSalt.new(:length => 20)
+  #     PasswordSalt.new
+  #
+  # If the first or second argument is a Symbol (other than <tt>:new</tt>), it 
+  # will be interpreted as the placement:
+  #     PasswordSalt.new(:before)
+  #     PasswordSalt.new(:new, :before)
+  #     PasswordSalt.new('ABCDEFG', :before)
+  #
+  # You may always pass in an options hash as the last argument.
+  # [length]    Length of salt to be generated.
+  #             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
+    
+    if self.string == :new
+      self.string = self.class.generate(options[:length] || DEFAULT_LENGTH)
+    end
+  end
+  
+  ##
+  # Returns the given password, but salted.
+  def salt_password( password )
+    case self.placement
+    when :after
+      password.to_s + string
+    when :before
+      string + password.to_s
+    when :split
+      string[0...(string.length/2).floor] + 
+        password.to_s + 
+        string[(string.length/2).floor...string.length]
+    else
+      raise "Invalid salt placement: #{self.placement}"
+    end
+  end
+  
+  ##
+  # Set the salt's placement
+  # 
+  # [after]   Place the salt after the password.
+  # [before]  Place the salt before the password.
+  # [split]   Place half of the salt before and half after the password.  For
+  #           salts of odd length, the shorter half will be in front.
+  def placement=( sym )
+    unless PLACEMENTS.include?(sym.to_sym)
+      raise ArgumentError, "Invalid salt placement: #{sym}"
+    end
+    @placement = sym.to_sym
+  end
+  
+  ##
+  # Returns the salt string.
+  def to_s
+    self.string
+  end
+  
+  ##
+  # Returns +true+ if the given salt is equivilent to this salt, +false+ otherwise
+  def eql?( salt )
+    self.to_s.eql?(salt.to_s) && self.placement.eql?(salt.placement)
+  end
+end

data/lib/dionysus/security/string.rb

@@ -1,9 +1,8 @@
-require 'digest/sha1'
-require 'digest/sha2'
-require 'digest/md5'
-
 require 'dionysus'
+require 'dionysus/digest'
 require 'dionysus/string'
+require 'dionysus/security/password_salt'
+
 ##
 # Adds String hashing and salting convenience methods.
 #
@@ -20,23 +19,32 @@ class String
   ##
   # Generate a random, binary salt with the given length (default 16)
   def self.salt( length = 16 )
-    length.times.to_a.collect {|val| rand(255).chr}.join[0...length]
+    PasswordSalt.generate(length, :binary).to_s
+  end
+  
+  ##
+  # Sanitize the String from memory.  This is non-reversible.  Runs 7 passes 
+  # by default.
+  #
+  def sanitize( passes = 7 )
+    passes.times do
+      (0...self.length).each { |i| self[i] = rand(256) }
+    end
+    (0...self.length).each { |i| self[i] = 0 }
+    self.delete!("\000")
   end
   
   ##
   # Generate the given digest hash.
   # 
   # Options:
-  # [salt]      Salt to append to the string.
-  #             Default: ''
-  # [encoding]  Encoding for the hash: <tt>:binary</tt>, <tt>:hex</tt>, <tt>:hexidecimal</tt>, <tt>:base64</tt>
+  # [salt]      Salt to append to the string. (This may be a String or a 
+  #             PasswordSalt object) Default: ''
+  # [encoding]  Encoding for the hash: <tt>:binary</tt>, <tt>:hex</tt>, 
+  #             <tt>:hexidecimal</tt>, <tt>:base64</tt>
   #             Default: <tt>:base64</tt>
   def digest( klass, options = {} )
-    unless klass.is_a?(Class)
-      klass = Digest.const_get(klass.to_s.upcase)
-    end
-    
-    digest = klass.digest(_salted(options[:salt]))
+    digest = Digest.digest(klass, _salted(options[:salt]))
     _encode(digest, options[:encoding] || :base64)
   end
   
@@ -52,12 +60,30 @@ class String
     super
   end
   
+  ##
+  # Detect the digest of the string
+  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."
+  end
+  
   private
   
   ##
-  # Salt the string by appending it to the end.
+  # Salt the string by appending it to the end or utilizing the 
+  # PasswordSalt's salt_password method
   def _salted( salt )
-    self + (salt || '')
+    return self if salt.blank?
+    
+    unless salt.is_a?(PasswordSalt)
+      salt = PasswordSalt.new(salt)
+    end
+    
+    salt.salt_password(self)
   end
   
   ##

data/lib/dionysus/string.rb

@@ -6,6 +6,9 @@ require 'active_support/base64'
 #
 #     require 'dionysus/string'
 class String
+  HEX_REGEXP = /^[a-f0-9]+$/
+  BASE64_REGEXP = /^[A-Za-z0-9\+\/\=]+$/
+  
   ##
   # Encode the Base64 (without newlines)
   def encode64s() Base64.encode64s(self); end
@@ -27,4 +30,18 @@ class String
   # Decode from hexidecimal
   def decode_hexidecimal() [self].pack('H*'); end
   alias_method :decode_hex, :decode_hexidecimal
+  
+  ##
+  # Detect the encoding of the string
+  def detect_encoding
+    return nil if blank?
+
+    if match(HEX_REGEXP)
+      :hex
+    elsif match(BASE64_REGEXP)
+      :base64
+    else
+      :binary
+    end
+  end
 end

data/spec/digest_spec.rb

@@ -0,0 +1,125 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'dionysus/digest'
+
+describe Digest do
+  it 'should have the default available digests' do
+    Digest.available_digests.length.should == Digest::DEFAULT_DIGESTS.length
+    Digest::DEFAULT_DIGESTS.each do |dig|
+      Digest.available_digests.should include(dig)
+    end
+  end
+  
+  describe 'registration' do
+    before(:all) do
+      Digest.digests.clear
+    end
+    
+    after(:each) do
+      Digest.digests.clear
+    end
+    
+    after(:all) do
+      Digest::DEFAULT_DIGESTS.each do |sym|
+        Digest.register_digest!(sym)
+      end
+    end
+    
+    it 'should register an available digest' do
+      Digest.register_digest(:md5).should be_a(Hash)
+      Digest.digests[:md5].should be_a(Hash)
+    end
+    
+    it 'should register an available digest with bang' do
+      Digest.register_digest!(:md5).should be_a(Hash)
+      Digest.digests[:md5].should be_a(Hash)
+    end
+    
+    it 'should automatically interpret the class' do
+      Digest.register_digest(:md5)
+      Digest.digests[:md5][:klass].should == Digest::MD5
+    end
+    
+    it 'should register a digest with a class' do
+      Digest.register_digest(:md5, :klass => Digest::SHA256)
+      Digest.digests[:md5][:klass].should == Digest::SHA256
+      Digest.digests[:md5][:bit_length].should == 256
+    end
+    
+    it 'should automatically interpret the bit length' do
+      Digest.register_digest(:md5)
+      Digest.digests[:md5][:bit_length].should == 128
+    end
+    
+    it 'should register a digest with a class and a bit length' do
+      Digest.register_digest(:md5, :klass => Digest::SHA256, :bit_length => 1)
+      Digest.digests[:md5][:klass].should == Digest::SHA256
+      Digest.digests[:md5][:bit_length].should == 1
+    end
+    
+    it 'should quietly reject a digest if it does not exist' do
+      Digest.register_digest(:foobar).should == nil
+      Digest.digests.should == {}
+    end
+    
+    it 'should raise an error if a digest does not exist' do
+      lambda { Digest.register_digest!(:foobar) }.should 
+             raise_error(LoadError, 'library not found for class Digest::FOOBAR -- digest/foobar')
+    end
+    
+    it 'should take an arbitrary object that responds to digest' do
+      my_digest = mock('my_digest')
+      my_digest.should_receive(:digest).with('1').and_return('12345')
+      Digest.register_digest(:my_digest, :klass => my_digest)
+      Digest.digests[:my_digest][:bit_length].should == 5 * 8
+      Digest.digests[:my_digest][:klass].should === my_digest
+      Digest.digests[:my_digest][:method].should == :digest
+    end
+    
+    it 'should take an arbitrary method' do
+      my_digest = mock('my_digest')
+      my_digest.should_receive(:do_digest).with('1').and_return('12345')
+      Digest.register_digest(:my_digest, :klass => my_digest, :method => :do_digest)
+      Digest.digests[:my_digest][:bit_length].should == 5 * 8
+      Digest.digests[:my_digest][:klass].should === my_digest
+      Digest.digests[:my_digest][:method].should == :do_digest
+    end
+  end
+  
+  describe 'digest lengths' do
+    { :md5 => 128, :sha1 => 160, :sha2 => 256, 
+      :sha256 => 256, :sha384 => 384, :sha512 => 512 }.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
+          Digest.digest_lengths(8)[dig].should == bits / 8
+        end
+        
+        it "should have hex length for #{dig}" do
+          Digest.digest_lengths(:hex)[dig].should == bits / 4
+          Digest.digest_lengths(:hexidecimal)[dig].should == bits / 4
+          Digest.digest_lengths(4)[dig].should == bits / 4
+        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
+        end
+
+        it "should have bit length for #{dig}" do
+          Digest.digest_lengths(:bit)[dig].should == bits
+          Digest.digest_lengths(1)[dig].should == bits
+        end
+        
+        it "should have arbitrary length for #{dig}" do
+          Digest.digest_lengths(7)[dig].should == bits / 7
+        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') }
+    end
+  end
+end

data/spec/password_salt_spec.rb

@@ -0,0 +1,159 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'dionysus/security/password_salt'
+describe PasswordSalt do
+  it "should not allow placements other than before, after, and split" do
+    salt = PasswordSalt.new('ABCDEFG')
+    [:before, :after, :split].each do |p|
+      salt.placement = p
+      salt.placement.should == p
+      salt.placement = p.to_s
+      salt.placement.should == p
+    end
+    
+    lambda { salt.placement = :wowsers }.should raise_error(ArgumentError, "Invalid salt placement: wowsers")
+  end
+  
+  it "should should return the salt string with to_s" do
+    salt = PasswordSalt.new('ABCDEFG')
+    salt.to_s.should == 'ABCDEFG'
+    salt = PasswordSalt.new('ABCDEFG', :after)
+    salt.to_s.should == 'ABCDEFG'
+    salt = PasswordSalt.new()
+    salt.to_s.should == salt.string
+  end
+  
+  it "should compare equivalance on both string and placement" do
+    salt1 = PasswordSalt.new('ABCDEFG')
+    salt2 = PasswordSalt.new('ABCDEFG')
+    salt1.eql?(salt2).should be_true
+    salt2.eql?(salt1).should be_true
+    
+    salt1 = PasswordSalt.new('ABCDEFG', :before)
+    salt2 = PasswordSalt.new('ABCDEFG', :before)
+    salt1.eql?(salt2).should be_true
+    salt2.eql?(salt1).should be_true
+    
+    salt1 = PasswordSalt.new('ABCDEFG', :before)
+    salt2 = PasswordSalt.new('ABCDEFG', :split)
+    salt1.eql?(salt2).should_not be_true
+    salt2.eql?(salt1).should_not be_true
+  end
+  
+  describe "initializer" do
+    it "should take the first string arg as the literal salt" do
+      salt = PasswordSalt.new('ABCDEFG')
+      salt.string.should == 'ABCDEFG'
+    end
+    
+    it "should take the the second symbold arg as the placement" do
+      salt = PasswordSalt.new('ABCDEFG', :before)
+      salt.placement.should == :before
+    end
+    
+    it "should generate a new salt of 8 characters and :after placement with no arguments" do
+      s = PasswordSalt.new
+      s.placement.should == :after
+      s.string.length.should == 8
+    end
+    
+    it "should take a length option" do
+      s = PasswordSalt.new(:length => 20)
+      s.placement.should == :after
+      s.string.length.should == 20
+    end
+  end
+  
+  describe "salt generation" do
+    it "should generate 8 characters by default" do
+      salt = PasswordSalt.generate
+      salt.length.should == 8
+    end
+    
+    it "should generate n characters when told to" do
+      (0..20).each do |n|
+        PasswordSalt.generate(n).length.should == n
+      end
+    end
+    
+    it "should raise an error with negative length" do
+      lambda { PasswordSalt.generate(-1) }.should raise_error(ArgumentError, "Invalid length: -1")
+    end
+    
+    it "should generate ascii characters only by default" do
+      100.times do
+        salt = PasswordSalt.generate(100)
+        salt.should match(/\A[A-Za-z0-9\+\/]{100}\Z/)
+      end
+    end
+    
+    it "should generate binary characters" do
+      100.times do
+        salt = PasswordSalt.generate(100, :binary)
+        salt.should_not match(/\A[A-Za-z0-9\+\/]{100}\Z/)
+      end
+    end
+  end
+  
+  describe "after placement" do
+    before(:each) do
+      @password = 'foobar'
+      @salt = "ABCDEFG"
+    end
+    
+    it "should put the salt after the password by default" do
+      salt = PasswordSalt.new(@salt)
+      salt.salt_password(@password).should == @password+@salt
+    end
+    
+    it "should put the salt after the password" do
+      salt = PasswordSalt.new(@salt, :after)
+      salt.salt_password(@password).should == @password+@salt
+    end
+  end
+  
+  describe "before placement" do
+    before(:each) do
+      @password = 'foobar'
+      @salt = "ABCDEFG"
+    end
+    
+    it "should put the salt before the password" do
+      salt = PasswordSalt.new(@salt, :before)
+      salt.salt_password(@password).should == @salt+@password
+      salt = PasswordSalt.new(@salt)
+      salt.placement = :before
+      salt.salt_password(@password).should == @salt+@password
+    end
+  end
+  
+  describe "split placement with even number of characters" do
+    before(:each) do
+      @password = 'foobar'
+      @salt = "ABCDEFGH"
+    end
+    
+    it "should put half the salt before and half the salt after the password" do
+      salt = PasswordSalt.new(@salt, :split)
+      salt.salt_password(@password).should == 'ABCD'+@password+'EFGH'
+      salt = PasswordSalt.new(@salt)
+      salt.placement = :split
+      salt.salt_password(@password).should == 'ABCD'+@password+'EFGH'
+    end
+  end
+  
+  describe "split placement with odd number of characters" do
+    before(:each) do
+      @password = 'foobar'
+      @salt = "ABCDEFG"
+    end
+    
+    it "should put half the salt before and half the salt after the password" do
+      salt = PasswordSalt.new(@salt, :split)
+      salt.salt_password(@password).should == 'ABC'+@password+'DEFG'
+      salt = PasswordSalt.new(@salt)
+      salt.placement = :split
+      salt.salt_password(@password).should == 'ABC'+@password+'DEFG'
+    end
+  end
+end

data/spec/string_security_spec.rb

@@ -11,6 +11,24 @@ describe String do
     String.salt(1).length.should == 1
   end
   
+  it "should sanitize the string" do
+    str = 'abcdefg'
+    str.sanitize
+    str.should == ''
+  end
+  
+  it "should sanitize the string with 0 passes" do
+    str = 'abcdefg'
+    str.sanitize(0)
+    str.should == ''
+  end
+  
+  it "should sanitize the string with 100 passes" do
+    str = 'abcdefg'
+    str.sanitize(100)
+    str.should == ''
+  end
+  
   it "should calculate sha512 in base64" do
     digest = "KHErTuI/5urCF3vi6yTDxvAHBydW1CN3zVfBWDP/ItbmgeVi5IFq47ew0hPHzyK3AuMDh+Z9MBBlf3/mACgVMQ=="
     "abcde\240z405".digest(:sha512).should == digest

data/spec/string_spec.rb

@@ -24,4 +24,23 @@ describe String do
     '6162636465a07a343035'.decode_hex.should == "abcde\240z405"
     '6162636465a07a343035'.decode_hexidecimal.should == "abcde\240z405"
   end
-end
+
+  describe 'encoding detection' do
+    it 'should return nil for blank' do
+      ''.detect_encoding.should be_nil
+    end
+    
+    it 'should match hex' do
+      '6162636465a07a343035'.detect_encoding.should == :hex
+    end
+    
+    it 'should match base64' do
+      "YWJjZGWgejQwNQ==".detect_encoding.should == :base64
+      "YWJjZGWgejQwNQ==\n".detect_encoding.should == :base64
+    end
+    
+    it 'should default to binary' do
+      "abcde\240z405".detect_encoding.should == :binary
+    end
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Travis D. Warlick, Jr.
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-21 00:00:00 -05:00
+date: 2010-04-02 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,14 +22,13 @@ dependencies:
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
-    - - "="
+    - - ~>
       - !ruby/object:Gem::Version 
         segments: 
         - 3
         - 0
         - 0
-        - beta
-        version: 3.0.0.beta
+        version: 3.0.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -65,11 +64,15 @@ files:
 - dionysus.gemspec
 - lib/dionysus.rb
 - lib/dionysus/configuration.rb
+- lib/dionysus/digest.rb
 - lib/dionysus/security.rb
+- lib/dionysus/security/password_salt.rb
 - lib/dionysus/security/string.rb
 - lib/dionysus/string.rb
 - spec/configuration_spec.rb
+- spec/digest_spec.rb
 - spec/dionysus_spec.rb
+- spec/password_salt_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/string_security_spec.rb
@@ -105,8 +108,10 @@ signing_key:
 specification_version: 3
 summary: A helpful set of utility classes, generators, and command-line tools.
 test_files: 
-- spec/string_spec.rb
-- spec/spec_helper.rb
 - spec/configuration_spec.rb
-- spec/string_security_spec.rb
+- spec/digest_spec.rb
 - spec/dionysus_spec.rb
+- spec/password_salt_spec.rb
+- spec/spec_helper.rb
+- spec/string_security_spec.rb
+- spec/string_spec.rb