bcrypt 3.1.7 → 3.1.8

checksums.yaml

@@ -1,7 +1,15 @@
---- 
-SHA512: 
-  metadata.gz: e9a27bd4544153b3e73771ddc6ee262227c7c666df2001028f0860b335810b3f01862d30c86c24d893fda4690298016c60f76accd467e95c9c9048945802d7b6
-  data.tar.gz: 1798cf7b86267393f52b54b31356aa6c54b9ad524d86b97354322b4ae9a032e472cd98fb4cd209ecf2372a7e55556b42173a0c2d16a7467d7cc4b2ef98343636
-SHA1: 
-  metadata.gz: d58ac651be05f4747ff8d8258d2fe0920e26f375
-  data.tar.gz: 8f7b7aad5c4c3f572dd172fac39fcd0de31012c5
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YmUwZGI3ZWM4NDc1NWZlZmVmMjY3MDJkYjQ1NDQ3NmY0OTI5NDI2Yw==
+  data.tar.gz: !binary |-
+    ZDBlODEzOTk1N2I5MDhlMjcwZGQ0NzcxZGJjNDI4ODQxMWM4MWE3MQ==
+SHA512:
+  metadata.gz: !binary |-
+    YzA0MmQyOTNkMjIzNjhjMzQxMTI3ODAxZGVmYzhmMzQ5YjY1N2Q0NmNhODJk
+    NTliYzI3NDk0YWRjZGMzYWY3ZmUxMzk5YzRkOGI4ZTdhZjQ5OWZmM2Y4MDlj
+    OGI1MDE2YmVhM2FhYThkM2M1MWI5MDBmYWVkOTJiMTE4ZjY1NWU=
+  data.tar.gz: !binary |-
+    MjY5Zjc5MjU2ZjkzYzhkYTk4ZWE1NTAyODZmMTljM2YxNzM3NGQxZmY1ZDcz
+    NWI4MjU2NzI4Y2MzYjI1YWZiY2EzMTcyYzk2NGMzYjNiNjA2M2JiMmJlMWYw
+    NDU3YjJlMTJmYTJlMDdjZDYzZTcwMmVhOWU2MDQ4MDZhYTg2NmI=

data/.gitignore

@@ -1,10 +1,9 @@
+doc
+pkg
+tmp
 *.o
 *.bundle
 *.so
 *.jar
-ext/mri/Makefile
-doc
-pkg
-*.class
-tmp/
 .DS_Store
+.rbenv-gemsets

data/.travis.yml

@@ -10,6 +10,5 @@ rvm:
   - jruby-19mode
   - jruby-head
   - rbx-2
-  - rbx
   - ree
 script: bundle exec rake

data/CHANGELOG

@@ -70,3 +70,6 @@
 3.1.7  Feb 24 2014
   - Rebuild corrupt Java binary version of gem [GH #90]
   - The 2.1 support for Windows binaries alleged in 3.1.3 was a lie -- documentation removed
+
+3.1.8  Oct 23 2014
+  - Add support for Ruby 2.1 in compiled Windows binaries [GH #102]

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bcrypt (3.1.7)
+    bcrypt (3.1.8)
 
 GEM
   remote: https://rubygems.org/
@@ -14,14 +14,18 @@ GEM
       rake
     rdoc (3.12.2)
       json (~> 1.4)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.7)
-    rspec-expectations (2.14.4)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.4)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.2)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.2)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.2)
 
 PLATFORMS
   java
@@ -33,4 +37,4 @@ DEPENDENCIES
   bcrypt!
   rake-compiler (~> 0.9.2)
   rdoc (~> 3.12)
-  rspec
+  rspec (>= 3)

data/README.md

@@ -30,7 +30,7 @@ re-hash those passwords. This vulnerability only affected the JRuby gem.
 The bcrypt gem is available on the following ruby platforms:
 
 * JRuby
-* RubyInstaller 1.8, 1.9, and 2.0 builds on win32
+* RubyInstaller 1.8, 1.9, 2.0, and 2.1 builds on win32
 * Any 1.8, 1.9, 2.0, or 2.1 ruby on a BSD/OSX/Linux system with a compiler
 
 ## How to use `bcrypt()` in your Rails application

data/Rakefile

@@ -7,16 +7,19 @@ require 'rdoc/task'
 require 'benchmark'
 
 CLEAN.include(
-  "ext/mri/*.o",
-  "ext/mri/*.bundle",
-  "ext/mri/*.so",
-  "ext/jruby/bcrypt_jruby/*.class"
+  "tmp",
+  "lib/1.8",
+  "lib/1.9",
+  "lib/2.0",
+  "lib/2.1",
+  "lib/bcrypt_ext.jar",
+  "lib/bcrypt_ext.so"
 )
 CLOBBER.include(
-  "ext/mri/Makefile",
-  "doc/coverage",
+  "doc",
   "pkg"
 )
+
 GEMSPEC = Gem::Specification.load("bcrypt.gemspec")
 
 task :default => [:compile, :spec]
@@ -58,6 +61,23 @@ else
     ext.cross_compile = true
     ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
   end
+
+  ENV['RUBY_CC_VERSION'].to_s.split(':').each do |ruby_version|
+    platforms = {
+      "x86-mingw32" => "i686-w64-mingw32",
+      "x64-mingw32" => "x86_64-w64-mingw32"
+    }
+    platforms.each do |platform, prefix|
+      task "copy:bcrypt_ext:#{platform}:#{ruby_version}" do |t|
+        %w[lib tmp/#{platform}/stage/lib].each do |dir|
+          so_file = "#{dir}/#{ruby_version[/^\d+\.\d+/]}/bcrypt_ext.so"
+          if File.exists?(so_file)
+            sh "#{prefix}-strip -S #{so_file}"
+          end
+        end
+      end
+    end
+  end
 end
 
 desc "Run a set of benchmarks on the compiled extension."

data/bcrypt.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'bcrypt'
-  s.version = '3.1.7'
+  s.version = '3.1.8'
 
   s.summary = "OpenBSD's bcrypt() password hashing algorithm."
   s.description = <<-EOF
@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.require_path = 'lib'
 
   s.add_development_dependency 'rake-compiler', '~> 0.9.2'
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', '>= 3'
   s.add_development_dependency 'rdoc', '~> 3.12'
 
   s.has_rdoc = true

data/ext/mri/extconf.rb

@@ -11,7 +11,6 @@ if RUBY_PLATFORM == "java"
   exit 0
 else
   require "mkmf"
-  have_header('ruby/util.h')
   dir_config("bcrypt_ext")
   create_makefile("bcrypt_ext")
 end

data/lib/bcrypt.rb

@@ -9,12 +9,7 @@ else
   require "openssl"
 end
 
-begin
-  RUBY_VERSION =~ /(\d+.\d+)/
-  require "#{$1}/bcrypt_ext"
-rescue LoadError
-  require "bcrypt_ext"
-end
+require 'bcrypt_ext'
 
 require 'bcrypt/error'
 require 'bcrypt/engine'

data/spec/bcrypt/engine_spec.rb

@@ -4,35 +4,35 @@ describe "The BCrypt engine" do
   specify "should calculate the optimal cost factor to fit in a specific time" do
     first = BCrypt::Engine.calibrate(100)
     second = BCrypt::Engine.calibrate(400)
-    second.should > first
+    expect(second).to be > first
   end
 end
 
 describe "Generating BCrypt salts" do
 
   specify "should produce strings" do
-    BCrypt::Engine.generate_salt.should be_an_instance_of(String)
+    expect(BCrypt::Engine.generate_salt).to be_an_instance_of(String)
   end
 
   specify "should produce random data" do
-    BCrypt::Engine.generate_salt.should_not equal(BCrypt::Engine.generate_salt)
+    expect(BCrypt::Engine.generate_salt).to_not equal(BCrypt::Engine.generate_salt)
   end
 
   specify "should raise a InvalidCostError if the cost parameter isn't numeric" do
-    lambda { BCrypt::Engine.generate_salt('woo') }.should raise_error(BCrypt::Errors::InvalidCost)
+    expect { BCrypt::Engine.generate_salt('woo') }.to raise_error(BCrypt::Errors::InvalidCost)
   end
 
   specify "should raise a InvalidCostError if the cost parameter isn't greater than 0" do
-    lambda { BCrypt::Engine.generate_salt(-1) }.should raise_error(BCrypt::Errors::InvalidCost)
+    expect { BCrypt::Engine.generate_salt(-1) }.to raise_error(BCrypt::Errors::InvalidCost)
   end
 end
 
 describe "Autodetecting of salt cost" do
 
   specify "should work" do
-    BCrypt::Engine.autodetect_cost("$2a$08$hRx2IVeHNsTSYYtUWn61Ou").should eq 8
-    BCrypt::Engine.autodetect_cost("$2a$05$XKd1bMnLgUnc87qvbAaCUu").should eq 5
-    BCrypt::Engine.autodetect_cost("$2a$13$Lni.CZ6z5A7344POTFBBV.").should eq 13
+    expect(BCrypt::Engine.autodetect_cost("$2a$08$hRx2IVeHNsTSYYtUWn61Ou")).to eq 8
+    expect(BCrypt::Engine.autodetect_cost("$2a$05$XKd1bMnLgUnc87qvbAaCUu")).to eq 5
+    expect(BCrypt::Engine.autodetect_cost("$2a$13$Lni.CZ6z5A7344POTFBBV.")).to eq 13
   end
 
 end
@@ -49,21 +49,21 @@ describe "Generating BCrypt hashes" do
   end
 
   specify "should produce a string" do
-    BCrypt::Engine.hash_secret(@password, @salt).should be_an_instance_of(String)
+    expect(BCrypt::Engine.hash_secret(@password, @salt)).to be_an_instance_of(String)
   end
 
   specify "should raise an InvalidSalt error if the salt is invalid" do
-    lambda { BCrypt::Engine.hash_secret(@password, 'nino') }.should raise_error(BCrypt::Errors::InvalidSalt)
+    expect { BCrypt::Engine.hash_secret(@password, 'nino') }.to raise_error(BCrypt::Errors::InvalidSalt)
   end
 
   specify "should raise an InvalidSecret error if the secret is invalid" do
-    lambda { BCrypt::Engine.hash_secret(MyInvalidSecret.new, @salt) }.should raise_error(BCrypt::Errors::InvalidSecret)
-    lambda { BCrypt::Engine.hash_secret(nil, @salt) }.should_not raise_error(BCrypt::Errors::InvalidSecret)
-    lambda { BCrypt::Engine.hash_secret(false, @salt) }.should_not raise_error(BCrypt::Errors::InvalidSecret)
+    expect { BCrypt::Engine.hash_secret(MyInvalidSecret.new, @salt) }.to raise_error(BCrypt::Errors::InvalidSecret)
+    expect { BCrypt::Engine.hash_secret(nil, @salt) }.not_to raise_error
+    expect { BCrypt::Engine.hash_secret(false, @salt) }.not_to raise_error
   end
 
   specify "should call #to_s on the secret and use the return value as the actual secret data" do
-    BCrypt::Engine.hash_secret(false, @salt).should == BCrypt::Engine.hash_secret("false", @salt)
+    expect(BCrypt::Engine.hash_secret(false, @salt)).to eq BCrypt::Engine.hash_secret("false", @salt)
   end
 
   specify "should be interoperable with other implementations" do
@@ -76,7 +76,7 @@ describe "Generating BCrypt hashes" do
       ["0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", "$2a$05$abcdefghijklmnopqrstuu", "$2a$05$abcdefghijklmnopqrstuu5s2v8.iXieOjg/.AySBTTZIIVFJeBui"]
     ]
     for secret, salt, test_vector in test_vectors
-      BCrypt::Engine.hash_secret(secret, salt).should eql(test_vector)
+      expect(BCrypt::Engine.hash_secret(secret, salt)).to eql(test_vector)
     end
   end
 end

data/spec/bcrypt/error_spec.rb

@@ -4,13 +4,13 @@ describe "Errors" do
 
   shared_examples "descends from StandardError" do
     it "can be rescued as a StandardError" do
-      described_class.should < StandardError
+      expect(described_class).to be < StandardError
     end
   end
 
   shared_examples "descends from BCrypt::Error" do
     it "can be rescued as a BCrypt::Error" do
-      described_class.should < BCrypt::Error
+      expect(described_class).to be < BCrypt::Error
     end
   end
 

data/spec/bcrypt/password_spec.rb

@@ -8,23 +8,23 @@ describe "Creating a hashed password" do
   end
 
   specify "should return a BCrypt::Password" do
-    @password.should be_an_instance_of(BCrypt::Password)
+    expect(@password).to be_an_instance_of(BCrypt::Password)
   end
 
   specify "should return a valid bcrypt password" do
-    lambda { BCrypt::Password.new(@password) }.should_not raise_error
+    expect { BCrypt::Password.new(@password) }.not_to raise_error
   end
 
   specify "should behave normally if the secret is not a string" do
-    lambda { BCrypt::Password.create(nil) }.should_not raise_error(BCrypt::Errors::InvalidSecret)
-    lambda { BCrypt::Password.create({:woo => "yeah"}) }.should_not raise_error(BCrypt::Errors::InvalidSecret)
-    lambda { BCrypt::Password.create(false) }.should_not raise_error(BCrypt::Errors::InvalidSecret)
+    expect { BCrypt::Password.create(nil) }.not_to raise_error
+    expect { BCrypt::Password.create({:woo => "yeah"}) }.not_to raise_error
+    expect { BCrypt::Password.create(false) }.not_to raise_error
   end
 
   specify "should tolerate empty string secrets" do
-    lambda { BCrypt::Password.create( "\n".chop  ) }.should_not raise_error
-    lambda { BCrypt::Password.create( ""         ) }.should_not raise_error
-    lambda { BCrypt::Password.create( String.new ) }.should_not raise_error
+    expect { BCrypt::Password.create( "\n".chop  ) }.not_to raise_error
+    expect { BCrypt::Password.create( ""         ) }.not_to raise_error
+    expect { BCrypt::Password.create( String.new ) }.not_to raise_error
   end
 end
 
@@ -35,26 +35,26 @@ describe "Reading a hashed password" do
   end
 
   specify "the cost is too damn high" do
-    lambda {
+    expect {
       BCrypt::Password.create("hello", :cost => 32)
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   specify "the cost should be set to the default if nil" do
-    BCrypt::Password.create("hello", :cost => nil).cost.should equal(BCrypt::Engine::DEFAULT_COST)
+    expect(BCrypt::Password.create("hello", :cost => nil).cost).to equal(BCrypt::Engine::DEFAULT_COST)
   end
 
   specify "the cost should be set to the default if empty hash" do
-    BCrypt::Password.create("hello", {}).cost.should equal(BCrypt::Engine::DEFAULT_COST)
+    expect(BCrypt::Password.create("hello", {}).cost).to equal(BCrypt::Engine::DEFAULT_COST)
   end
 
   specify "the cost should be set to the passed value if provided" do
-    BCrypt::Password.create("hello", :cost => 5).cost.should equal(5)
+    expect(BCrypt::Password.create("hello", :cost => 5).cost).to equal(5)
   end
 
   specify "the cost should be set to the global value if set" do
     BCrypt::Engine.cost = 5
-    BCrypt::Password.create("hello").cost.should equal(5)
+    expect(BCrypt::Password.create("hello").cost).to equal(5)
     # unset the global value to not affect other tests
     BCrypt::Engine.cost = nil
   end
@@ -65,7 +65,7 @@ describe "Reading a hashed password" do
     old_default_cost = BCrypt::Engine::DEFAULT_COST
 
     BCrypt::Engine::DEFAULT_COST = 5
-    BCrypt::Password.create("hello").cost.should equal(5)
+    expect(BCrypt::Password.create("hello").cost).to equal(5)
 
     # reset default to not affect other tests
     BCrypt::Engine::DEFAULT_COST = old_default_cost
@@ -74,17 +74,17 @@ describe "Reading a hashed password" do
 
   specify "should read the version, cost, salt, and hash" do
     password = BCrypt::Password.new(@hash)
-    password.version.should eql("2a")
-    password.cost.should equal(5)
-    password.salt.should eql("$2a$05$CCCCCCCCCCCCCCCCCCCCC.")
-    password.salt.class.should eq String
-    password.checksum.should eq("E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW")
-    password.checksum.class.should eq String
-    password.to_s.should eql(@hash)
+    expect(password.version).to eql("2a")
+    expect(password.cost).to equal(5)
+    expect(password.salt).to eql("$2a$05$CCCCCCCCCCCCCCCCCCCCC.")
+    expect(password.salt.class).to eq String
+    expect(password.checksum).to eq("E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW")
+    expect(password.checksum.class).to eq String
+    expect(password.to_s).to eql(@hash)
   end
 
   specify "should raise an InvalidHashError when given an invalid hash" do
-    lambda { BCrypt::Password.new('weedle') }.should raise_error(BCrypt::Errors::InvalidHash)
+    expect { BCrypt::Password.new('weedle') }.to raise_error(BCrypt::Errors::InvalidHash)
   end
 end
 
@@ -96,28 +96,28 @@ describe "Comparing a hashed password with a secret" do
   end
 
   specify "should compare successfully to the original secret" do
-    (@password == @secret).should be(true)
+    expect((@password == @secret)).to be(true)
   end
 
   specify "should compare unsuccessfully to anything besides original secret" do
-    (@password == "@secret").should be(false)
+    expect((@password == "@secret")).to be(false)
   end
 end
 
 describe "Validating a generated salt" do
   specify "should not accept an invalid salt" do
-    BCrypt::Engine.valid_salt?("invalid").should eq(false)
+    expect(BCrypt::Engine.valid_salt?("invalid")).to eq(false)
   end
   specify "should accept a valid salt" do
-    BCrypt::Engine.valid_salt?(BCrypt::Engine.generate_salt).should eq(true)
+    expect(BCrypt::Engine.valid_salt?(BCrypt::Engine.generate_salt)).to eq(true)
   end
 end
 
 describe "Validating a password hash" do
   specify "should not accept an invalid password" do
-    BCrypt::Password.valid_hash?("i_am_so_not_valid").should be_false
+    expect(BCrypt::Password.valid_hash?("i_am_so_not_valid")).to be_falsey
   end
   specify "should accept a valid password" do
-    BCrypt::Password.valid_hash?(BCrypt::Password.create "i_am_so_valid").should be_true
+    expect(BCrypt::Password.valid_hash?(BCrypt::Password.create "i_am_so_valid")).to be_truthy
   end
 end

metadata

@@ -1,54 +1,65 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: bcrypt
-version: !ruby/object:Gem::Version 
-  version: 3.1.7
+version: !ruby/object:Gem::Version
+  version: 3.1.8
 platform: ruby
-authors: 
+authors:
 - Coda Hale
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2014-02-25 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-10-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake-compiler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 0.9.2
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - &id004 
-      - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rdoc
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        version: "3.12"
+      - !ruby/object:Gem::Version
+        version: '3.12'
   type: :development
-  version_requirements: *id003
-description: "    bcrypt() is a sophisticated and secure hash algorithm designed by The OpenBSD project\n    for hashing passwords. The bcrypt Ruby gem provides a simple wrapper for safely handling\n    passwords.\n"
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: ! "    bcrypt() is a sophisticated and secure hash algorithm designed
+  by The OpenBSD project\n    for hashing passwords. The bcrypt Ruby gem provides
+  a simple wrapper for safely handling\n    passwords.\n"
 email: coda.hale@gmail.com
 executables: []
-
-extensions: 
+extensions:
 - ext/mri/extconf.rb
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.md
 - COPYING
 - CHANGELOG
@@ -56,7 +67,7 @@ extra_rdoc_files:
 - lib/bcrypt/error.rb
 - lib/bcrypt/password.rb
 - lib/bcrypt.rb
-files: 
+files:
 - .gitignore
 - .rspec
 - .travis.yml
@@ -86,32 +97,33 @@ files:
 - spec/bcrypt/password_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/codahale/bcrypt-ruby
-licenses: 
+licenses:
 - MIT
 metadata: {}
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --title
 - bcrypt-ruby
 - --line-numbers
 - --inline-source
 - --main
 - README.md
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id004
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id004
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: OpenBSD's bcrypt() password hashing algorithm.
 test_files: []
-