bcrypt-ruby 2.0.5 → 2.1.0

data/ext/{bcrypt.c → mri/bcrypt.c}

@@ -1,6 +1,11 @@
 /*	$OpenBSD: bcrypt.c,v 1.22 2007/02/20 01:44:16 ray Exp $	*/
 
 /*
+ * Modified by <hongli@phusion.nl> on 2009-08-05:
+ *
+ *   - Got rid of the global variables; they're not thread-safe.
+ *     Modified the functions to accept local buffers instead.
+ *
  * Modified by <coda.hale@gmail.com> on 2007-02-27:
  *
  *   - Changed bcrypt_gensalt to accept a random seed as a parameter,
@@ -62,27 +67,17 @@
 #include <sys/types.h>
 #include <string.h>
 #include "blf.h"
+#include "bcrypt.h"
 
 /* This implementation is adaptable to current computing power.
  * You can have up to 2^31 rounds which should be enough for some
  * time to come.
  */
 
-#define BCRYPT_VERSION '2'
-#define BCRYPT_MAXSALT 16	/* Precomputation is just so nice */
-#define BCRYPT_BLOCKS 6		/* Ciphertext blocks */
-#define BCRYPT_MINROUNDS 16	/* we have log2(rounds) in salt */
-
-char   *bcrypt_gensalt(u_int8_t, u_int8_t *);
-
 static void encode_salt(char *, u_int8_t *, u_int16_t, u_int8_t);
 static void encode_base64(u_int8_t *, u_int8_t *, u_int16_t);
 static void decode_base64(u_int8_t *, u_int16_t, u_int8_t *);
 
-static char    encrypted[_PASSWORD_LEN];
-static char    gsalt[7 + (BCRYPT_MAXSALT * 4 + 2) / 3 + 1];
-static char    error[] = ":";
-
 const static u_int8_t Base64Code[] =
 "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 
@@ -155,22 +150,22 @@ encode_salt(char *salt, u_int8_t *csalt, u_int16_t clen, u_int8_t logr)
    seems sensible.
  */
 
-char *
-bcrypt_gensalt(u_int8_t log_rounds, u_int8_t *rseed)
+char   *
+bcrypt_gensalt(char *output, u_int8_t log_rounds, u_int8_t *rseed)
 {
 	if (log_rounds < 4)
 		log_rounds = 4;
 	else if (log_rounds > 31)
 		log_rounds = 31;
 
-	encode_salt(gsalt, rseed, BCRYPT_MAXSALT, log_rounds);
-	return gsalt;
+	encode_salt(output, rseed, BCRYPT_MAXSALT, log_rounds);
+	return output;
 }
 /* We handle $Vers$log2(NumRounds)$salt+passwd$
    i.e. $2$04$iwouldntknowwhattosayetKdJ6iFtacBqJdKe6aW7ou */
 
 char   *
-bcrypt(const char *key, const char *salt)
+bcrypt(char *output, const char *key, const char *salt)
 {
 	blf_ctx state;
 	u_int32_t rounds, i, k;
@@ -185,8 +180,7 @@ bcrypt(const char *key, const char *salt)
 	salt++;
 
 	if (*salt > BCRYPT_VERSION) {
-		/* How do I handle errors ? Return ':' */
-		return error;
+		return NULL;
 	}
 
 	/* Check for minor versions */
@@ -198,7 +192,7 @@ bcrypt(const char *key, const char *salt)
 			 salt++;
 			 break;
 		 default:
-			 return error;
+			 return NULL;
 		 }
 	} else
 		 minor = 0;
@@ -208,21 +202,21 @@ bcrypt(const char *key, const char *salt)
 
 	if (salt[2] != '$')
 		/* Out of sync with passwd entry */
-		return error;
+		return NULL;
 
 	/* Computer power doesn't increase linear, 2^x should be fine */
 	n = atoi(salt);
 	if (n > 31 || n < 0)
-		return error;
+		return NULL;
 	logr = (u_int8_t)n;
 	if ((rounds = (u_int32_t) 1 << logr) < BCRYPT_MINROUNDS)
-		return error;
+		return NULL;
 
 	/* Discard num rounds + "$" identifier */
 	salt += 3;
 
 	if (strlen(salt) * 3 / 4 < BCRYPT_MAXSALT)
-		return error;
+		return NULL;
 
 	/* We dont want the base64 salt but the raw data */
 	decode_base64(csalt, BCRYPT_MAXSALT, (u_int8_t *) salt);
@@ -259,18 +253,18 @@ bcrypt(const char *key, const char *salt)
 
 
 	i = 0;
-	encrypted[i++] = '$';
-	encrypted[i++] = BCRYPT_VERSION;
+	output[i++] = '$';
+	output[i++] = BCRYPT_VERSION;
 	if (minor)
-		encrypted[i++] = minor;
-	encrypted[i++] = '$';
+		output[i++] = minor;
+	output[i++] = '$';
 
-	snprintf(encrypted + i, 4, "%2.2u$", logr);
+	snprintf(output + i, 4, "%2.2u$", logr);
 
-	encode_base64((u_int8_t *) encrypted + i + 3, csalt, BCRYPT_MAXSALT);
-	encode_base64((u_int8_t *) encrypted + strlen(encrypted), ciphertext,
+	encode_base64((u_int8_t *) output + i + 3, csalt, BCRYPT_MAXSALT);
+	encode_base64((u_int8_t *) output + strlen(output), ciphertext,
 	    4 * BCRYPT_BLOCKS - 1);
-	return encrypted;
+	return output;
 }
 
 static void

data/ext/mri/bcrypt.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Niels Provos.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _BCRYPT_H_
+#define _BCRYPT_H_
+
+#define BCRYPT_VERSION '2'
+#define BCRYPT_MAXSALT 16	/* Precomputation is just so nice */
+#define BCRYPT_BLOCKS 6		/* Ciphertext blocks */
+#define BCRYPT_MINROUNDS 16	/* we have log2(rounds) in salt */
+#define BCRYPT_SALT_OUTPUT_SIZE  (7 + (BCRYPT_MAXSALT * 4 + 2) / 3 + 1)
+#define BCRYPT_OUTPUT_SIZE 128
+
+/*
+ * Given a logarithmic cost parameter, generates a salt for use with bcrypt().
+ *
+ * output: the computed salt will be stored here. This buffer must be
+ *         at least BCRYPT_SALT_OUTPUT_SIZE bytes. The result will be
+ *         null-terminated.
+ * log_rounds: the logarithmic cost.
+ * rseed: a seed of BCRYPT_MAXSALT bytes. Should be obtained from a
+ *        cryptographically secure random source.
+ * Returns: output
+ */
+char *bcrypt_gensalt(char *output, u_int8_t log_rounds, u_int8_t *rseed);
+
+/*
+ * Given a secret and a salt, generates a salted hash (which you can then store safely).
+ *
+ * output: the computed salted hash will be stored here. This buffer must
+ *         be at least BCRYPT_OUTPUT_SIZE bytes, and will become null-terminated.
+ * key: A null-terminated secret.
+ * salt: The salt, as generated by bcrypt_gensalt().
+ * Returns: output on success, NULL on error.
+ */
+char *bcrypt(char *output, const char *key, const char *salt);
+
+#endif /* _BCRYPT_H_ */

data/ext/mri/bcrypt_ext.c

@@ -0,0 +1,87 @@
+#include "ruby.h"
+#include "bcrypt.h"
+
+static VALUE mBCrypt;
+static VALUE cBCryptEngine;
+
+/* Define RSTRING_PTR for Ruby 1.8.5, ruby-core's idea of a point release is
+   insane. */
+#ifndef RSTRING_PTR
+#  define    RSTRING_PTR(s)  (RSTRING(s)->ptr)
+#endif
+
+#ifdef RUBY_VM
+#  define RUBY_1_9
+#endif
+
+#ifdef RUBY_1_9
+
+	/* When on Ruby 1.9+, we will want to unlock the GIL while performing
+	 * expensive calculations, for greater concurrency. Do not do this for
+	 * cheap calculations because locking/unlocking the GIL incurs some overhead as well.
+	 */
+	#define GIL_UNLOCK_COST_THRESHOLD 9
+	
+	typedef struct {
+		char       *output;
+		const char *key;
+		const char *salt;
+	} BCryptArguments;
+	
+	static VALUE bcrypt_wrapper(void *_args) {
+		BCryptArguments *args = (BCryptArguments *)_args;
+		return (VALUE)bcrypt(args->output, args->key, args->salt);
+	}
+
+#endif /* RUBY_1_9 */
+
+/* Given a logarithmic cost parameter, generates a salt for use with +bc_crypt+.
+ */
+static VALUE bc_salt(VALUE self, VALUE cost, VALUE seed) {
+	int icost = NUM2INT(cost);
+	char salt[BCRYPT_SALT_OUTPUT_SIZE];
+	
+	bcrypt_gensalt(salt, icost, (u_int8_t *)RSTRING_PTR(seed));
+	return rb_str_new2(salt);
+}
+
+/* Given a secret and a salt, generates a salted hash (which you can then store safely).
+ */
+static VALUE bc_crypt(VALUE self, VALUE key, VALUE salt, VALUE cost) {
+	const char * safeguarded = RSTRING_PTR(key) ? RSTRING_PTR(key) : "";
+	char output[BCRYPT_OUTPUT_SIZE];
+	
+	#ifdef RUBY_1_9
+		int icost = NUM2INT(cost);
+		if (icost >= GIL_UNLOCK_COST_THRESHOLD) {
+			BCryptArguments args;
+			VALUE ret;
+		
+			args.output = output;
+			args.key    = safeguarded;
+			args.salt   = RSTRING_PTR(salt);
+			ret = rb_thread_blocking_region(bcrypt_wrapper, &args, RUBY_UBF_IO, 0);
+			if (ret != (VALUE) 0) {
+				return rb_str_new2(output);
+			} else {
+				return Qnil;
+			}
+		}
+		/* otherwise, fallback to the non-GIL-unlocking code, just like on Ruby 1.8 */
+	#endif
+	
+	if (bcrypt(output, safeguarded, (char *)RSTRING_PTR(salt)) != NULL) {
+		return rb_str_new2(output);
+	} else {
+		return Qnil;
+	}
+}
+
+/* Create the BCrypt and BCrypt::Engine modules, and populate them with methods. */
+void Init_bcrypt_ext(){
+	mBCrypt = rb_define_module("BCrypt");
+	cBCryptEngine = rb_define_class_under(mBCrypt, "Engine", rb_cObject);
+	
+	rb_define_singleton_method(cBCryptEngine, "__bc_salt", bc_salt, 2);
+	rb_define_singleton_method(cBCryptEngine, "__bc_crypt", bc_crypt, 3);
+}

data/ext/mri/extconf.rb

@@ -0,0 +1,18 @@
+if RUBY_PLATFORM == "java"
+  # Don't do anything when run in JRuby; this allows gem installation to pass.
+  # We need to write a dummy Makefile so that RubyGems doesn't think compilation
+  # failed.
+  File.open('Makefile', 'w') do |f|
+    f.puts "all:"
+    f.puts "\t@true"
+    f.puts "install:"
+    f.puts "\t@true"
+  end
+  exit 0
+else
+  require "mkmf"
+  dir_config("bcrypt_ext")
+  # enable this when we're feeling nitpicky
+  # CONFIG['CC'] << " -Wall "
+  create_makefile("bcrypt_ext")
+end

data/lib/bcrypt.rb

@@ -1,8 +1,13 @@
 # A wrapper for OpenBSD's bcrypt/crypt_blowfish password-hashing algorithm.
 
-$: << "ext"
-require "bcrypt_ext"
-require "openssl"
+if RUBY_PLATFORM == "java"
+  require 'java'
+  $CLASSPATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "ext", "jruby"))
+else
+  $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "ext", "mri")))
+  require "bcrypt_ext"
+  require "openssl"
+end
 
 # A Ruby library implementing OpenBSD's bcrypt()/crypt_blowfish algorithm for
 # hashing passwords.
@@ -14,24 +19,36 @@ module BCrypt
     class InvalidSecret < StandardError; end  # The secret parameter provided to bcrypt() is invalid.
   end
   
-  # A Ruby wrapper for the bcrypt() extension calls.
+  # A Ruby wrapper for the bcrypt() C extension calls and the Java calls.
   class Engine
     # The default computational expense parameter.
     DEFAULT_COST    = 10
+    # The minimum cost supported by the algorithm.
+    MIN_COST        = 4
     # Maximum possible size of bcrypt() salts.
     MAX_SALT_LENGTH = 16
     
-    # C-level routines which, if they don't get the right input, will crash the
-    # hell out of the Ruby process.
-    private_class_method :__bc_salt
-    private_class_method :__bc_crypt
+    if RUBY_PLATFORM != "java"
+      # C-level routines which, if they don't get the right input, will crash the
+      # hell out of the Ruby process.
+      private_class_method :__bc_salt
+      private_class_method :__bc_crypt
+    end
     
     # Given a secret and a valid salt (see BCrypt::Engine.generate_salt) calculates
     # a bcrypt() password hash.
-    def self.hash_secret(secret, salt)
+    def self.hash_secret(secret, salt, cost = nil)
       if valid_secret?(secret)
         if valid_salt?(salt)
-          __bc_crypt(secret.to_s, salt)
+          if cost.nil?
+            cost = autodetect_cost(salt)
+          end
+          
+          if RUBY_PLATFORM == "java"
+            Java.bcrypt_jruby.BCrypt.hashpw(secret.to_s, salt.to_s)
+          else
+            __bc_crypt(secret.to_s, salt, cost)
+          end
         else
           raise Errors::InvalidSalt.new("invalid salt")
         end
@@ -42,8 +59,16 @@ module BCrypt
     
     # Generates a random salt with a given computational cost.
     def self.generate_salt(cost = DEFAULT_COST)
-      if cost.to_i > 0
-        __bc_salt(cost, OpenSSL::Random.random_bytes(MAX_SALT_LENGTH))
+      cost = cost.to_i
+      if cost > 0
+        if cost < MIN_COST
+          cost = MIN_COST
+        end
+        if RUBY_PLATFORM == "java"
+          Java.bcrypt_jruby.BCrypt.gensalt(cost)
+        else
+          __bc_salt(cost, OpenSSL::Random.random_bytes(MAX_SALT_LENGTH))
+        end
       else
         raise Errors::InvalidCost.new("cost must be numeric and > 0")
       end
@@ -79,6 +104,11 @@ module BCrypt
         return i if end_time * 1_000 > upper_time_limit_in_ms
       end
     end
+    
+    # Autodetects the cost from the salt string.
+    def self.autodetect_cost(salt)
+      salt[4..5].to_i
+    end
   end
   
   # A password management class which allows you to safely store users' passwords and compare them.
@@ -123,7 +153,7 @@ module BCrypt
       # 
       #   @password = BCrypt::Password.create("my secret", :cost => 13)
       def create(secret, options = { :cost => BCrypt::Engine::DEFAULT_COST })
-        Password.new(BCrypt::Engine.hash_secret(secret, BCrypt::Engine.generate_salt(options[:cost])))
+        Password.new(BCrypt::Engine.hash_secret(secret, BCrypt::Engine.generate_salt(options[:cost]), options[:cost]))
       end
     end
     

data/spec/bcrypt/engine_spec.rb

@@ -1,10 +1,10 @@
-require File.join(File.dirname(__FILE__), "..", "spec_helper")
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
 
 context "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(300)
-    second.should >(first + 1)
+    second = BCrypt::Engine.calibrate(400)
+    second.should > first
   end
 end
 
@@ -27,9 +27,23 @@ context "Generating BCrypt salts" do
   end
 end
 
+context "Autodetecting of salt cost" do
+  
+  specify "should work" do
+    BCrypt::Engine.autodetect_cost("$2a$08$hRx2IVeHNsTSYYtUWn61Ou").should == 8
+    BCrypt::Engine.autodetect_cost("$2a$05$XKd1bMnLgUnc87qvbAaCUu").should == 5
+    BCrypt::Engine.autodetect_cost("$2a$13$Lni.CZ6z5A7344POTFBBV.").should == 13
+  end
+  
+end
+
 context "Generating BCrypt hashes" do
   
-  setup do
+  class MyInvalidSecret
+    undef to_s
+  end
+  
+  before :each do
     @salt = BCrypt::Engine.generate_salt(4)
     @password = "woo"
   end
@@ -43,10 +57,15 @@ context "Generating BCrypt hashes" do
   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)
   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)
+  end
+  
   specify "should be interoperable with other implementations" do
     # test vectors from the OpenWall implementation <http://www.openwall.com/crypt/>
     test_vectors = [