digest-kangarootwelve 0.0.2 → 0.3.2

data/ext/digest/kangarootwelve/ext.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 konsolebox
+ * Copyright (c) 2017-2018 konsolebox
  *
  * MIT License
  *
@@ -23,14 +23,15 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#include "KangarooTwelve.h"
 #include <ruby.h>
 #include <ruby/digest.h>
 
+#include "KangarooTwelve.h"
+#include "utils.h"
+
 #define KT_DEFAULT_DIGEST_LENGTH 64 /* 512 bits */
-#define KT_DEFAULT_BLOCK_LENGTH 8192 * 8 /* chunkSize * Parallellism */
+#define KT_BLOCK_LENGTH 8192 /* chunkSize */
 #define KT_MIN_DIGEST_LENGTH 1
-#define KT_MIN_BLOCK_LENGTH 64
 
 #define KT_DIGEST_API_VERSION_IS_SUPPORTED(version) (version == 3)
 
@@ -44,7 +45,9 @@ static ID _id_auto;
 static ID _id_block_length;
 static ID _id_b;
 static ID _id_customization;
+static ID _id_customization_hex;
 static ID _id_c;
+static ID _id_ch;
 static ID _id_default;
 static ID _id_digest_length;
 static ID _id_d;
@@ -55,11 +58,10 @@ static ID _id_new;
 static ID _id_n;
 static ID _id_unpack;
 
-static VALUE _module_Digest;
-static VALUE _class_Digest_Base;
-static VALUE _module_Digest_KangarooTwelve;
-static VALUE _class_Digest_KangarooTwelve_Impl;
-static VALUE _class_Digest_KangarooTwelve_Metadata;
+static VALUE _Digest;
+static VALUE _Digest_KangarooTwelve;
+static VALUE _Digest_KangarooTwelve_Impl;
+static VALUE _Digest_KangarooTwelve_Metadata;
 
 typedef struct {
 	KangarooTwelve_Instance instance;
@@ -69,38 +71,63 @@ typedef struct {
 #define KT_CONTEXT kangarootwelve_context_t
 #define KT_CONTEXT_PTR(void_ctx_ptr) ((KT_CONTEXT *) void_ctx_ptr)
 
+#define _RSTRING_PTR_U(x) (unsigned char *)RSTRING_PTR(x)
+
 static void check_digest_length(int digest_length)
 {
 	if (!(digest_length >= KT_MIN_DIGEST_LENGTH))
 		rb_raise(rb_eArgError, "Digest length lesser than minimum (%d): %d", KT_MIN_DIGEST_LENGTH, digest_length);
 }
 
-static void check_block_length(int block_length)
+static VALUE hex_encode_str(VALUE str)
+{
+	int len;
+	VALUE hex;
+
+	len = RSTRING_LEN(str);
+	hex = rb_str_new(0, len * 2);
+	hex_encode_str_implied(_RSTRING_PTR_U(str), len, _RSTRING_PTR_U(hex));
+	return hex;
+}
+
+static VALUE hex_decode_str(VALUE str)
 {
-	if (!(block_length >= KT_MIN_BLOCK_LENGTH))
-		rb_raise(rb_eArgError, "Block length lesser than minimum (%d): %d", KT_MIN_BLOCK_LENGTH, block_length);
+	int len;
+	VALUE decoded;
+
+	len = RSTRING_LEN(str);
+	decoded = rb_str_new(0, calc_hex_decoded_str_length(len));
+
+	if (! hex_decode_str_implied(_RSTRING_PTR_U(str), len, _RSTRING_PTR_U(decoded))) {
+		VALUE inspect = rb_inspect(str);
+		rb_raise(rb_eArgError, "Failed to decode hex string %s.", RSTRING_PTR(inspect));
+	}
+
+	return decoded;
 }
 
 static int kangarootwelve_init(void *ctx)
 {
+	VALUE klass_or_instance, digest_length, digest_length_int, customization;
+
 	if (ctx == NULL)
 		rb_raise(rb_eRuntimeError, "Context pointer is NULL.");
 
-	VALUE klass_or_instance = rb_current_receiver();
+	klass_or_instance = rb_current_receiver();
 
-	if (TYPE(klass_or_instance) == T_CLASS && klass_or_instance == _class_Digest_KangarooTwelve_Impl)
+	if (TYPE(klass_or_instance) == T_CLASS && klass_or_instance == _Digest_KangarooTwelve_Impl)
 		rb_raise(rb_eStandardError, "Digest::KangarooTwelve::Impl is a base class and cannot be instantiated.");
 
-	VALUE digest_length = rb_funcall(klass_or_instance, _id_digest_length, 0);
+	digest_length = rb_funcall(klass_or_instance, _id_digest_length, 0);
 
 	if (TYPE(digest_length) != T_FIXNUM)
 		rb_raise(rb_eTypeError, "Invalid object type for digest length.");
 
-	int digest_length_int = FIX2INT(digest_length);
+	digest_length_int = FIX2INT(digest_length);
 
 	check_digest_length(digest_length_int);
 
-	VALUE customization = rb_funcall(klass_or_instance, _id_customization, 0);
+	customization = rb_funcall(klass_or_instance, _id_customization, 0);
 
 	if (TYPE(customization) != T_NIL && TYPE(customization) != T_STRING)
 		rb_raise(rb_eTypeError, "Invalid object type for a customization string.");
@@ -127,34 +154,34 @@ static void kangarootwelve_update(void *ctx, unsigned char *data, size_t length)
 
 static int kangarootwelve_finish(void *ctx, unsigned char *data)
 {
+	VALUE customization;
+
 	if (ctx == NULL)
 		rb_raise(rb_eRuntimeError, "Context pointer is NULL.");
 
-	VALUE customization = KT_CONTEXT_PTR(ctx)->customization;
+	customization = KT_CONTEXT_PTR(ctx)->customization;
 
 	switch (TYPE(customization)) {
 	case T_NIL:
 		return KangarooTwelve_Final(&KT_CONTEXT_PTR(ctx)->instance, data, 0, 0) == 0;
 	case T_STRING:
-		return KangarooTwelve_Final(&KT_CONTEXT_PTR(ctx)->instance, data, RSTRING_PTR(customization),
-				RSTRING_LEN(customization)) == 0;
+		return KangarooTwelve_Final(&KT_CONTEXT_PTR(ctx)->instance, data,
+				_RSTRING_PTR_U(customization), RSTRING_LEN(customization)) == 0;
 	default:
 		rb_raise(rb_eRuntimeError, "Object type of customization string became invalid.");
 	}
 }
 
-static VALUE do_nothing(VALUE self)
+static VALUE implement(VALUE name, VALUE digest_length, VALUE customization)
 {
-	return Qnil;
-}
+	VALUE impl_class, impl_class_name, prev_digest_length, metadata_obj;
+	ID impl_class_name_id, id;
+	int digest_length_int, prev_digest_length_int;
+	rb_digest_metadata_t *metadata;
 
-static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALUE customization)
-{
 	if (!KT_DIGEST_API_VERSION_IS_SUPPORTED(RUBY_DIGEST_API_VERSION))
 		rb_raise(rb_eRuntimeError, "Digest API version is not supported.");
 
-	int digest_length_int, block_length_int;
-
 	switch (TYPE(digest_length)) {
 	case T_NIL:
 		digest_length_int = KT_DEFAULT_DIGEST_LENGTH;
@@ -167,18 +194,6 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 		rb_raise(rb_eTypeError, "Invalid value type for digest length.");
 	}
 
-	switch (TYPE(block_length)) {
-	case T_NIL:
-		block_length_int = KT_DEFAULT_BLOCK_LENGTH;
-		break;
-	case T_FIXNUM:
-		block_length_int = FIX2INT(block_length);
-		check_block_length(block_length_int);
-		break;
-	default:
-		rb_raise(rb_eTypeError, "Invalid value type for block length.");
-	}
-
 	switch (TYPE(customization)) {
 	case T_NIL:
 	case T_STRING:
@@ -187,8 +202,7 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 		rb_raise(rb_eTypeError, "Invalid value type for customization string.");
 	}
 
-	VALUE impl_class_name = Qnil;
-	ID impl_class_name_id, id;
+	impl_class_name = Qnil;
 
 	switch (TYPE(name)) {
 	case T_NIL:
@@ -198,12 +212,7 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 
 		if (id == _id_auto) {
 			if (customization != Qnil) {
-				VALUE customization_hex_in_array = rb_funcall(customization, _id_unpack, 1, rb_str_new_literal("H*"));
-				VALUE customization_hex = rb_ary_pop(customization_hex_in_array);
-				impl_class_name = rb_sprintf("KangarooTwelve_%d_%d_%s", digest_length_int, block_length_int,
-						StringValueCStr(customization_hex));
-			} else if (block_length_int != KT_DEFAULT_BLOCK_LENGTH) {
-				impl_class_name = rb_sprintf("KangarooTwelve_%d_%d", digest_length_int, block_length_int);
+				impl_class_name = hex_encode_str(customization);
 			} else {
 				impl_class_name = rb_sprintf("KangarooTwelve_%d", digest_length_int);
 			}
@@ -228,13 +237,11 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 		rb_raise(rb_eTypeError, "Invalid argument type for class name.");
 	}
 
-	VALUE impl_class;
-
 	if (impl_class_name == Qnil) {
-		impl_class = rb_funcall(rb_cClass, _id_new, 1, _class_Digest_KangarooTwelve_Impl);
+		impl_class = rb_funcall(rb_cClass, _id_new, 1, _Digest_KangarooTwelve_Impl);
 	} else {
-		if (rb_const_defined(_module_Digest, impl_class_name_id)) {
-			impl_class = rb_const_get(_module_Digest, impl_class_name_id);
+		if (rb_const_defined(_Digest, impl_class_name_id)) {
+			impl_class = rb_const_get(_Digest, impl_class_name_id);
 
 			if (TYPE(impl_class) != T_CLASS) {
 				rb_raise(rb_eTypeError,
@@ -242,13 +249,13 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 						StringValueCStr(impl_class_name));
 			}
 
-			if (rb_class_superclass(impl_class) != _class_Digest_KangarooTwelve_Impl) {
+			if (rb_class_superclass(impl_class) != _Digest_KangarooTwelve_Impl) {
 				rb_raise(rb_eTypeError,
 						"Digest::%s was already defined but not derived from Digest::KangarooTwelve::Impl.",
 						StringValueCStr(impl_class_name));
 			}
 
-			VALUE prev_digest_length = rb_ivar_get(impl_class, _id_digest_length);
+			prev_digest_length = rb_ivar_get(impl_class, _id_digest_length);
 
 			if (TYPE(prev_digest_length) != T_FIXNUM) {
 				rb_raise(rb_eRuntimeError,
@@ -256,7 +263,7 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 						StringValueCStr(impl_class_name));
 			}
 
-			int prev_digest_length_int = FIX2INT(prev_digest_length);
+			prev_digest_length_int = FIX2INT(prev_digest_length);
 
 			if (prev_digest_length_int != digest_length_int) {
 				rb_raise(rb_eTypeError,
@@ -266,37 +273,17 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 						digest_length_int);
 			}
 
-			VALUE prev_block_length = rb_ivar_get(impl_class, _id_block_length);
-
-			if (TYPE(prev_block_length) != T_FIXNUM) {
-				rb_raise(rb_eRuntimeError,
-						"Previous definition of Digest::%s has invalid block length value type.",
-						StringValueCStr(impl_class_name));
-			}
-
-			int prev_block_length_int = FIX2INT(prev_block_length);
-
-			if (prev_block_length_int != block_length_int) {
-				rb_raise(rb_eTypeError,
-						"Digest::%s was already defined but has different block length (%d instead of %d).",
-						StringValueCStr(impl_class_name),
-						prev_block_length_int,
-						block_length_int);
-			}
-
 			return impl_class;
 		}
 
-		impl_class = rb_define_class_id_under(_module_Digest, impl_class_name_id, _class_Digest_KangarooTwelve_Impl);
+		impl_class = rb_define_class_id_under(_Digest, impl_class_name_id, _Digest_KangarooTwelve_Impl);
 	}
 
-	VALUE metadata_obj;
-	rb_digest_metadata_t *metadata;
-	metadata_obj = Data_Make_Struct(_class_Digest_KangarooTwelve_Metadata, rb_digest_metadata_t, 0, -1, metadata);
+	metadata_obj = Data_Make_Struct(_Digest_KangarooTwelve_Metadata, rb_digest_metadata_t, 0, -1, metadata);
 
 	metadata->api_version = RUBY_DIGEST_API_VERSION;
 	metadata->digest_len = digest_length_int;
-	metadata->block_len = block_length_int;
+	metadata->block_len = KT_BLOCK_LENGTH;
 	metadata->ctx_size = sizeof(KT_CONTEXT);
 	metadata->init_func = kangarootwelve_init;
 	metadata->update_func = kangarootwelve_update;
@@ -304,7 +291,7 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
 
 	rb_ivar_set(impl_class, _id_metadata, metadata_obj);
 	rb_ivar_set(impl_class, _id_digest_length, INT2FIX(digest_length_int));
-	rb_ivar_set(impl_class, _id_block_length, INT2FIX(block_length_int));
+	rb_ivar_set(impl_class, _id_block_length, INT2FIX(KT_BLOCK_LENGTH));
 	rb_ivar_set(impl_class, _id_customization, customization);
 
 	return impl_class;
@@ -314,16 +301,25 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
  * Document-module: Digest::KangarooTwelve
  *
  * The Digest::KangarooTwelve module is the main component of the KangarooTwelve
- * extension.
+ * extension for Ruby.
  *
- * To create a hashing object, one must use one of the singleton methods in this
- * module to produce an implementation class, which can then be used to create
- * the hashing object.
+ * It contains singleton methods that can be used to create implementation
+ * classes.  These implementation classes can then be used to create instances
+ * for producing hashes.
  *
- * An example to this is <code>hash = Digest::KangarooTwelve[32].new</code>.
+ * Example:
  *
- * The produced implementation class and the hash object can be used just like
- * any other implementation classes and instances in Digest.
+ * <tt>Digest::KangarooTwelve[32].new.update("one").update("two").digest</tt>
+ *
+ * The implementation classes can also be used to directly produce hashes.
+ *
+ * Example:
+ *
+ * <tt>Digest::KangarooTwelve[32].hexdigest("1234")</tt>
+ *
+ * The produced implementation classes and their instances can be used just like
+ * any other classes and instances in the Digest namespace that's based on
+ * Digest::Base.
  */
 
 /*
@@ -332,12 +328,15 @@ static VALUE implement(VALUE name, VALUE digest_length, VALUE block_length, VALU
  * Returns the default implementation class which has a digest length of 64
  * bytes, and doesn't have a customization string.
  */
-VALUE rbx_Digest_KangarooTwelve_singleton_default(VALUE self)
+static VALUE _Digest_KangarooTwelve_singleton_default(VALUE self)
 {
-	VALUE default_ = rb_ivar_get(self, _id_default);
+	VALUE default_ = Qnil;
+
+	if (rb_ivar_defined(self, _id_default) == Qtrue)
+		default_ = rb_ivar_get(self, _id_default);
 
 	if (NIL_P(default_)) {
-		default_ = implement(ID2SYM(_id_auto), INT2FIX(KT_DEFAULT_DIGEST_LENGTH), Qnil, Qnil);
+		default_ = implement(ID2SYM(_id_auto), INT2FIX(KT_DEFAULT_DIGEST_LENGTH), Qnil);
 		rb_ivar_set(self, _id_default, default_);
 	}
 
@@ -360,15 +359,12 @@ VALUE rbx_Digest_KangarooTwelve_singleton_default(VALUE self)
  *   module.
  *
  *   The default value for this option is +:auto+, and it implies automatic
- *   generation of the name.  The generated name is in the format of
- *   Digest::KangarooTwelve_<digest_length> if neither a customization string
- *   nor a custom block length is specified.
+ *   generation of the name.  The generated name is in the form of
+ *   Digest::KangarooTwelve_<digest_length> if a customization string is not
+ *   specified.
  *
- *   If a customization string is specified, the format would become
- *   Digest::KangarooTwelve_<digest_length>_<block_length>_<cust_str_hex>.
- *
- *   If no customization string is specified but a custom block is, the format
- *   would be Digest::KangarooTwelve_<digest_length>_<block_length>.
+ *   If a customization string is specified, the format would be
+ *   Digest::KangarooTwelve_<digest_length>_<cust_str_hex>.
  *
  *   Specifying a string would make the method produce Digest::<string>.
  *
@@ -381,30 +377,25 @@ VALUE rbx_Digest_KangarooTwelve_singleton_default(VALUE self)
  *
  *   See Digest::KangarooTwelve::DEFAULT_DIGEST_LENGTH for the default value.
  *
- * :b, :block_length ::
- *   Specifies a custom block length.  This doesn't affect the digest results
- *   and is mostly just used for tweaking performance or memory usage.  Examine
- *   the update function in KangarooTwelve.c to know if this is needed to be
- *   configured.
- *
- *   See Digest::KangarooTwelve::DEFAULT_BLOCK_LENGTH for the default value.
- *
  * :c, :customization ::
  *   Specifies the customization string.  Adding a customization string changes
  *   the resulting digest of every input.
  *
- * Calling the method with no argument would be the same as calling the
+ * :ch, :customization_hex ::
+ *   Specifies the customization string in hex mode.
+ *
+ * Calling the method with no argument is the same as calling the
  * Digest::KangarooTwelve::default method.
  */
-VALUE rbx_Digest_KangarooTwelve_singleton_implement(int argc, VALUE *argv, VALUE self)
+static VALUE _Digest_KangarooTwelve_singleton_implement(int argc, VALUE *argv, VALUE self)
 {
-	VALUE opts, name, digest_length, block_length, customization;
+	VALUE opts, name, digest_length, customization;
 
 	rb_scan_args(argc, argv, "0:", &opts);
 
 	if (NIL_P(opts)) {
 		name = ID2SYM(_id_auto);
-		digest_length = block_length = customization = Qnil;
+		digest_length = customization = Qnil;
 	} else {
 		name = rb_hash_lookup2(opts, ID2SYM(_id_n), Qundef);
 
@@ -416,18 +407,29 @@ VALUE rbx_Digest_KangarooTwelve_singleton_implement(int argc, VALUE *argv, VALUE
 		if (digest_length == Qundef)
 			digest_length = rb_hash_lookup2(opts, ID2SYM(_id_digest_length), Qnil);
 
-		block_length = rb_hash_lookup2(opts, ID2SYM(_id_b), Qundef);
-
-		if (block_length == Qundef)
-			block_length = rb_hash_lookup2(opts, ID2SYM(_id_block_length), Qnil);
-
 		customization = rb_hash_lookup2(opts, ID2SYM(_id_c), Qundef);
 
 		if (customization == Qundef)
-			customization = rb_hash_lookup2(opts, ID2SYM(_id_customization), Qnil);
+			customization = rb_hash_lookup2(opts, ID2SYM(_id_customization), Qundef);
+
+		if (customization == Qundef) {
+			VALUE customization_hex = rb_hash_lookup2(opts, ID2SYM(_id_customization_hex), Qundef);
+
+			if (customization_hex == Qundef)
+				customization_hex = rb_hash_lookup2(opts, ID2SYM(_id_ch), Qundef);
+
+			if (customization_hex == Qundef) {
+				customization = Qnil;
+			} else {
+				if (TYPE(customization_hex) != T_STRING)
+					rb_raise(rb_eTypeError, "Customization argument not a string.");
+
+				customization = hex_decode_str(customization_hex);
+			}
+		}
 	}
 
-	return implement(name, digest_length, block_length, customization);
+	return implement(name, digest_length, customization);
 }
 
 /*
@@ -440,9 +442,9 @@ VALUE rbx_Digest_KangarooTwelve_singleton_implement(int argc, VALUE *argv, VALUE
  * Digest::KangarooTwelve_<digest_length>, and can be directly referenced after
  * this method is called.
  */
-VALUE rbx_Digest_KangarooTwelve_singleton_implement_simple(VALUE self, VALUE digest_length)
+static VALUE _Digest_KangarooTwelve_singleton_implement_simple(VALUE self, VALUE digest_length)
 {
-	return implement(ID2SYM(_id_auto), digest_length, Qnil, Qnil);
+	return implement(ID2SYM(_id_auto), digest_length, Qnil);
 }
 
 /*
@@ -459,12 +461,12 @@ VALUE rbx_Digest_KangarooTwelve_singleton_implement_simple(VALUE self, VALUE dig
  *
  * Creates a new object instance of the implementation class.
  */
-VALUE rbx_Digest_KangarooTwelve_Impl_singleton_new(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_singleton_new(VALUE self)
 {
-	if (self == _class_Digest_KangarooTwelve_Impl)
+	if (self == _Digest_KangarooTwelve_Impl)
 		rb_raise(rb_eRuntimeError, "Digest::KangarooTwelve::Impl is an abstract class.");
 
-	if (rb_obj_class(rb_ivar_get(self, _id_metadata)) != _class_Digest_KangarooTwelve_Metadata)
+	if (rb_ivar_defined(self, _id_metadata) == Qfalse || rb_obj_class(rb_ivar_get(self, _id_metadata)) != _Digest_KangarooTwelve_Metadata)
 		rb_raise(rb_eRuntimeError, "Metadata not set or invalid.  Please do not manually inherit KangarooTwelve.");
 
 	return rb_call_super(0, 0);
@@ -475,9 +477,9 @@ VALUE rbx_Digest_KangarooTwelve_Impl_singleton_new(VALUE self)
  *
  * Returns configured digest length of the implementation class.
  */
-VALUE rbx_Digest_KangarooTwelve_Impl_singleton_digest_length(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_singleton_digest_length(VALUE self)
 {
-	if (self == _class_Digest_KangarooTwelve_Impl)
+	if (self == _Digest_KangarooTwelve_Impl)
 		rb_raise(rb_eRuntimeError, "Digest::KangarooTwelve::Impl is an abstract class.");
 
 	return rb_ivar_get(self, _id_digest_length);
@@ -486,14 +488,11 @@ VALUE rbx_Digest_KangarooTwelve_Impl_singleton_digest_length(VALUE self)
 /*
  * call-seq: block_length -> int
  *
- * Returns configured block length of the implementation class.
+ * Returns 8192.
  */
-VALUE rbx_Digest_KangarooTwelve_Impl_singleton_block_length(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_singleton_block_length(VALUE self)
 {
-	if (self == _class_Digest_KangarooTwelve_Impl)
-		rb_raise(rb_eRuntimeError, "Digest::KangarooTwelve::Impl is an abstract class.");
-
-	return rb_ivar_get(self, _id_block_length);
+	return INT2FIX(KT_BLOCK_LENGTH);
 }
 
 /*
@@ -501,12 +500,36 @@ VALUE rbx_Digest_KangarooTwelve_Impl_singleton_block_length(VALUE self)
  *
  * Returns configured customization string of the implementation class.
  */
-VALUE rbx_Digest_KangarooTwelve_Impl_singleton_customization(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_singleton_customization(VALUE self)
 {
-	if (self == _class_Digest_KangarooTwelve_Impl)
+	if (self == _Digest_KangarooTwelve_Impl)
 		rb_raise(rb_eRuntimeError, "Digest::KangarooTwelve::Impl is an abstract class.");
 
-	return rb_ivar_get(self, _id_customization);
+	return rb_ivar_defined(self, _id_customization) == Qtrue ? rb_ivar_get(self, _id_customization) : Qnil;
+}
+
+/*
+ * call-seq: customization_hex -> string or nil
+ *
+ * Returns configured customization string of the implementation class in hex.
+ */
+static VALUE _Digest_KangarooTwelve_Impl_singleton_customization_hex(VALUE self)
+{
+	if (self == _Digest_KangarooTwelve_Impl)
+		rb_raise(rb_eRuntimeError, "Digest::KangarooTwelve::Impl is an abstract class.");
+
+	if (rb_ivar_defined(self, _id_customization)) {
+		VALUE customization = rb_ivar_get(self, _id_customization);
+
+		if (!NIL_P(customization)) {
+			if (TYPE(customization) != T_STRING)
+				rb_raise(rb_eTypeError, "Unexpected class for a customization string.");
+
+			return hex_encode_str(customization);
+		}
+	}
+
+	return Qnil;
 }
 
 /*
@@ -514,7 +537,7 @@ VALUE rbx_Digest_KangarooTwelve_Impl_singleton_customization(VALUE self)
  *
  * Returns configured customization string of the implementation object.
  */
-VALUE rbx_Digest_KangarooTwelve_Impl_customization(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_customization(VALUE self)
 {
 	VALUE customization;
 
@@ -529,26 +552,41 @@ VALUE rbx_Digest_KangarooTwelve_Impl_customization(VALUE self)
 	return customization;
 }
 
+/*
+ * call-seq: customization_hex -> string or nil
+ *
+ * Returns configured customization string of the implementation object in hex.
+ */
+static VALUE _Digest_KangarooTwelve_Impl_customization_hex(VALUE self)
+{
+	VALUE customization = rb_funcall(self, _id_customization, 0);
+	return hex_encode_str(customization);
+}
+
 /*
  * call-seq: inspect -> string
  *
- * Returns a string in the format of #<implementation_class_name|digest_length|block_length|customization_string|digest>
+ * Returns a string in the form of #<impl_class_name|digest_length|hex_cust_string|hex_digest>
  */
-VALUE rbx_Digest_KangarooTwelve_inspect(VALUE self)
+static VALUE _Digest_KangarooTwelve_Impl_inspect(VALUE self)
 {
-	VALUE klass = rb_obj_class(self);
-	VALUE klass_name = rb_class_name(klass);
+	VALUE klass, klass_name, digest_length, customization_hex, hexdigest, args[4];
+
+	klass = rb_obj_class(self);
+	klass_name = rb_class_name(klass);
 
 	if (klass_name == Qnil)
 		klass_name = rb_inspect(klass);
 
-	VALUE digest_length = rb_funcall(self, _id_digest_length, 0);
-	VALUE block_length = rb_funcall(self, _id_block_length, 0);
-	VALUE customization = rb_funcall(self, _id_customization, 0);
-	VALUE hexdigest = rb_funcall(self, _id_hexdigest, 0);
+	digest_length = rb_funcall(self, _id_digest_length, 0);
+	customization_hex = rb_funcall(self, _id_customization_hex, 0);
+	hexdigest = rb_funcall(self, _id_hexdigest, 0);
 
-	VALUE args[] = { klass_name, digest_length, block_length, customization, hexdigest };
-	return rb_str_format(sizeof(args), args, rb_str_new_literal("#<%s|%d|%d|%s|%s>"));
+	args[0] = klass_name;
+	args[1] = digest_length;
+	args[2] = customization_hex;
+	args[3] = hexdigest;
+	return rb_str_format(sizeof(args), args, rb_str_new_literal("#<%s:%d|%s|%s>"));
 }
 
 /*
@@ -562,7 +600,9 @@ void Init_kangarootwelve()
 	DEFINE_ID(auto)
 	DEFINE_ID(block_length)
 	DEFINE_ID(b)
+	DEFINE_ID(ch)
 	DEFINE_ID(customization)
+	DEFINE_ID(customization_hex)
 	DEFINE_ID(c)
 	DEFINE_ID(default)
 	DEFINE_ID(digest_length)
@@ -575,66 +615,77 @@ void Init_kangarootwelve()
 	DEFINE_ID(unpack)
 
 	rb_require("digest");
-	_module_Digest = rb_path2class("Digest");
-	_class_Digest_Base = rb_path2class("Digest::Base");
+	_Digest = rb_path2class("Digest");
 
 	#if 0
-	_module_Digest = rb_define_module("Digest"); /* Tell RDoc about Digest since it doesn't recognize rb_path2class. */
+	_Digest = rb_define_module("Digest"); /* Tell RDoc about Digest since it doesn't recognize rb_path2class. */
 	#endif
 
 	/*
-	 * module Digest::KangarooTwelve
+	 * Document-module: Digest::KangarooTwelve
 	 */
 
-	_module_Digest_KangarooTwelve = rb_define_module_under(_module_Digest, "KangarooTwelve");
+	_Digest_KangarooTwelve = rb_define_module_under(_Digest, "KangarooTwelve");
 
-	rb_define_singleton_method(_module_Digest_KangarooTwelve, "default",
-			rbx_Digest_KangarooTwelve_singleton_default, 0);
-	rb_define_singleton_method(_module_Digest_KangarooTwelve, "implement",
-			rbx_Digest_KangarooTwelve_singleton_implement, -1);
-	rb_define_singleton_method(_module_Digest_KangarooTwelve, "[]",
-			rbx_Digest_KangarooTwelve_singleton_implement_simple, 1);
+	rb_define_singleton_method(_Digest_KangarooTwelve, "default",
+			_Digest_KangarooTwelve_singleton_default, 0);
+	rb_define_singleton_method(_Digest_KangarooTwelve, "implement",
+			_Digest_KangarooTwelve_singleton_implement, -1);
+	rb_define_singleton_method(_Digest_KangarooTwelve, "[]",
+			_Digest_KangarooTwelve_singleton_implement_simple, 1);
 
 	/*
-	 * Currently 65536 bytes (8192 x 8)
+	 * Document-const: Digest::KangarooTwelve::BLOCK_LENGTH
+	 *
+	 * 8192 bytes
 	 */
 
-	rb_define_const(_module_Digest_KangarooTwelve, "DEFAULT_BLOCK_LENGTH", INT2FIX(KT_DEFAULT_BLOCK_LENGTH));
+	/* 8192 bytes */
+
+	rb_define_const(_Digest_KangarooTwelve, "BLOCK_LENGTH", INT2FIX(KT_BLOCK_LENGTH));
 
 	/*
+	 * Document-const: Digest::KangarooTwelve::DEFAULT_DIGEST_LENGTH
+	 *
 	 * 64 bytes (512 bits)
 	 */
 
-	rb_define_const(_module_Digest_KangarooTwelve, "DEFAULT_DIGEST_LENGTH", INT2FIX(KT_DEFAULT_DIGEST_LENGTH));
+	/* 64 bytes (512 bits) */
+
+	rb_define_const(_Digest_KangarooTwelve, "DEFAULT_DIGEST_LENGTH", INT2FIX(KT_DEFAULT_DIGEST_LENGTH));
 
 	/*
-	 * class Digest::KangarooTwelve::Impl < Digest::Base
+	 * Document-class: Digest::KangarooTwelve::Impl
 	 */
 
-	_class_Digest_KangarooTwelve_Impl = rb_define_class_under(_module_Digest_KangarooTwelve, "Impl",
-			_class_Digest_Base);
-
-	rb_define_singleton_method(_class_Digest_KangarooTwelve_Impl, "new",
-			rbx_Digest_KangarooTwelve_Impl_singleton_new, 0);
-	rb_define_singleton_method(_class_Digest_KangarooTwelve_Impl, "block_length",
-			rbx_Digest_KangarooTwelve_Impl_singleton_block_length, 0);
-	rb_define_singleton_method(_class_Digest_KangarooTwelve_Impl, "digest_length",
-			rbx_Digest_KangarooTwelve_Impl_singleton_digest_length, 0);
-	rb_define_singleton_method(_class_Digest_KangarooTwelve_Impl, "customization",
-			rbx_Digest_KangarooTwelve_Impl_singleton_customization, 0);
-
-	rb_define_method(_class_Digest_KangarooTwelve_Impl, "customization",
-			rbx_Digest_KangarooTwelve_Impl_customization, 0);
-	rb_define_method(_class_Digest_KangarooTwelve_Impl, "inspect",
-			rbx_Digest_KangarooTwelve_inspect, 0);
+	_Digest_KangarooTwelve_Impl = rb_define_class_under(_Digest_KangarooTwelve, "Impl",
+			rb_path2class("Digest::Base"));
+
+	rb_define_singleton_method(_Digest_KangarooTwelve_Impl, "new",
+			_Digest_KangarooTwelve_Impl_singleton_new, 0);
+	rb_define_singleton_method(_Digest_KangarooTwelve_Impl, "block_length",
+			_Digest_KangarooTwelve_Impl_singleton_block_length, 0);
+	rb_define_singleton_method(_Digest_KangarooTwelve_Impl, "digest_length",
+			_Digest_KangarooTwelve_Impl_singleton_digest_length, 0);
+	rb_define_singleton_method(_Digest_KangarooTwelve_Impl, "customization",
+			_Digest_KangarooTwelve_Impl_singleton_customization, 0);
+	rb_define_singleton_method(_Digest_KangarooTwelve_Impl, "customization_hex",
+			_Digest_KangarooTwelve_Impl_singleton_customization_hex, 0);
+
+	rb_define_method(_Digest_KangarooTwelve_Impl, "customization",
+			_Digest_KangarooTwelve_Impl_customization, 0);
+	rb_define_method(_Digest_KangarooTwelve_Impl, "customization_hex",
+			_Digest_KangarooTwelve_Impl_customization_hex, 0);
+	rb_define_method(_Digest_KangarooTwelve_Impl, "inspect",
+			_Digest_KangarooTwelve_Impl_inspect, 0);
 
 	/*
-	 * class Digest::KangarooTwelve::Metadata < Data
+	 * Document-class: Digest::KangarooTwelve::Metadata
 	 *
 	 * This class represents the internal metadata produced for the
 	 * implementation classes.
 	 */
 
-	_class_Digest_KangarooTwelve_Metadata = rb_define_class_under(_module_Digest_KangarooTwelve, "Metadata",
-			rb_path2class("Data"));
+	_Digest_KangarooTwelve_Metadata = rb_define_class_under(_Digest_KangarooTwelve, "Metadata",
+			rb_cObject);
 }