digest-kangarootwelve 0.0.1

data/ext/digest/kangarootwelve/align.h

@@ -0,0 +1,34 @@
+/*
+Implementation by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
+Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer, hereby
+denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our websites:
+http://keccak.noekeon.org/
+http://keyak.noekeon.org/
+http://ketje.noekeon.org/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _align_h_
+#define _align_h_
+
+/* on Mac OS-X and possibly others, ALIGN(x) is defined in param.h, and -Werror chokes on the redef. */
+#ifdef ALIGN
+#undef ALIGN
+#endif
+
+#if defined(__GNUC__)
+#define ALIGN(x) __attribute__ ((aligned(x)))
+#elif defined(_MSC_VER)
+#define ALIGN(x) __declspec(align(x))
+#elif defined(__ARMCC_VERSION)
+#define ALIGN(x) __align(x)
+#else
+#define ALIGN(x)
+#endif
+
+#endif

data/ext/digest/kangarootwelve/brg_endian.h

@@ -0,0 +1,142 @@
+/*
+ ---------------------------------------------------------------------------
+ Copyright (c) 1998-2008, Brian Gladman, Worcester, UK. All rights reserved.
+
+ LICENSE TERMS
+
+ The redistribution and use of this software (with or without changes)
+ is allowed without the payment of fees or royalties provided that:
+
+  1. source code distributions include the above copyright notice, this
+     list of conditions and the following disclaimer;
+
+  2. binary distributions include the above copyright notice, this list
+     of conditions and the following disclaimer in their documentation;
+
+  3. the name of the copyright holder is not used to endorse products
+     built using this software without specific written permission.
+
+ DISCLAIMER
+
+ This software is provided 'as is' with no explicit or implied warranties
+ in respect of its properties, including, but not limited to, correctness
+ and/or fitness for purpose.
+ ---------------------------------------------------------------------------
+ Issue Date: 20/12/2007
+ Changes for ARM 9/9/2010
+*/
+
+#ifndef _BRG_ENDIAN_H
+#define _BRG_ENDIAN_H
+
+#define IS_BIG_ENDIAN      4321 /* byte 0 is most significant (mc68k) */
+#define IS_LITTLE_ENDIAN   1234 /* byte 0 is least significant (i386) */
+
+#if 0
+/* Include files where endian defines and byteswap functions may reside */
+#if defined( __sun )
+#  include <sys/isa_defs.h>
+#elif defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __NetBSD__ )
+#  include <sys/endian.h>
+#elif defined( BSD ) && ( BSD >= 199103 ) || defined( __APPLE__ ) || \
+      defined( __CYGWIN32__ ) || defined( __DJGPP__ ) || defined( __osf__ )
+#  include <machine/endian.h>
+#elif defined( __linux__ ) || defined( __GNUC__ ) || defined( __GNU_LIBRARY__ )
+#  if !defined( __MINGW32__ ) && !defined( _AIX )
+#    include <endian.h>
+#    if !defined( __BEOS__ )
+#      include <byteswap.h>
+#    endif
+#  endif
+#endif
+#endif
+
+/* Now attempt to set the define for platform byte order using any  */
+/* of the four forms SYMBOL, _SYMBOL, __SYMBOL & __SYMBOL__, which  */
+/* seem to encompass most endian symbol definitions                 */
+
+#if defined( BIG_ENDIAN ) && defined( LITTLE_ENDIAN )
+#  if defined( BYTE_ORDER ) && BYTE_ORDER == BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( BYTE_ORDER ) && BYTE_ORDER == LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( _BIG_ENDIAN ) && defined( _LITTLE_ENDIAN )
+#  if defined( _BYTE_ORDER ) && _BYTE_ORDER == _BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( _BYTE_ORDER ) && _BYTE_ORDER == _LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( _BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( _LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN ) && defined( __LITTLE_ENDIAN )
+#  if defined( __BYTE_ORDER ) && __BYTE_ORDER == __BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( __BYTE_ORDER ) && __BYTE_ORDER == __LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( __BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN__ ) && defined( __LITTLE_ENDIAN__ )
+#  if defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __BIG_ENDIAN__
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __LITTLE_ENDIAN__
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( __BIG_ENDIAN__ )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN__ )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+/*  if the platform byte order could not be determined, then try to */
+/*  set this define using common machine defines                    */
+#if !defined(PLATFORM_BYTE_ORDER)
+
+#if   defined( __alpha__ ) || defined( __alpha ) || defined( i386 )       || \
+      defined( __i386__ )  || defined( _M_I86 )  || defined( _M_IX86 )    || \
+      defined( __OS2__ )   || defined( sun386 )  || defined( __TURBOC__ ) || \
+      defined( vax )       || defined( vms )     || defined( VMS )        || \
+      defined( __VMS )     || defined( _M_X64 )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+
+#elif defined( AMIGA )   || defined( applec )    || defined( __AS400__ )  || \
+      defined( _CRAY )   || defined( __hppa )    || defined( __hp9000 )   || \
+      defined( ibm370 )  || defined( mc68000 )   || defined( m68k )       || \
+      defined( __MRC__ ) || defined( __MVS__ )   || defined( __MWERKS__ ) || \
+      defined( sparc )   || defined( __sparc)    || defined( SYMANTEC_C ) || \
+      defined( __VOS__ ) || defined( __TIGCC__ ) || defined( __TANDEM )   || \
+      defined( THINK_C ) || defined( __VMCMS__ ) || defined( _AIX )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+
+#elif defined(__arm__)
+# ifdef __BIG_ENDIAN
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# else
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif 1     /* **** EDIT HERE IF NECESSARY **** */
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#elif 0     /* **** EDIT HERE IF NECESSARY **** */
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#else
+#  error Please edit lines 132 or 134 in brg_endian.h to set the platform byte order
+#endif
+
+#endif
+
+#endif

data/ext/digest/kangarootwelve/ext.c

@@ -0,0 +1,640 @@
+/*
+ * Copyright (c) 2017 konsolebox
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "KangarooTwelve.h"
+#include <ruby.h>
+#include <ruby/digest.h>
+
+#define KT_DEFAULT_DIGEST_LENGTH 64 /* 512 bits */
+#define KT_DEFAULT_BLOCK_LENGTH 8192 * 8 /* chunkSize * Parallellism */
+#define KT_MIN_DIGEST_LENGTH 1
+#define KT_MIN_BLOCK_LENGTH 64
+
+#define KT_DIGEST_API_VERSION_IS_SUPPORTED(version) (version == 3)
+
+#if !(KT_DIGEST_API_VERSION_IS_SUPPORTED(RUBY_DIGEST_API_VERSION))
+#	error Digest API version is not supported.
+#endif
+
+#define KT_DEBUG(...) fprintf(stderr, __VA_ARGS__)
+
+static ID _id_auto;
+static ID _id_block_length;
+static ID _id_b;
+static ID _id_customization;
+static ID _id_c;
+static ID _id_default;
+static ID _id_digest_length;
+static ID _id_d;
+static ID _id_hexdigest;
+static ID _id_metadata;
+static ID _id_name;
+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;
+
+typedef struct {
+	KangarooTwelve_Instance instance;
+	VALUE customization;
+} kangarootwelve_context_t;
+
+#define KT_CONTEXT kangarootwelve_context_t
+#define KT_CONTEXT_PTR(void_ctx_ptr) ((KT_CONTEXT *) void_ctx_ptr)
+
+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)
+{
+	if (!(block_length >= KT_MIN_BLOCK_LENGTH))
+		rb_raise(rb_eArgError, "Block length lesser than minimum (%d): %d", KT_MIN_BLOCK_LENGTH, block_length);
+}
+
+static int kangarootwelve_init(void *ctx)
+{
+	if (ctx == NULL)
+		rb_raise(rb_eRuntimeError, "Context pointer is NULL.");
+
+	VALUE klass_or_instance = rb_current_receiver();
+
+	if (TYPE(klass_or_instance) == T_CLASS && klass_or_instance == _class_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);
+
+	if (TYPE(digest_length) != T_FIXNUM)
+		rb_raise(rb_eTypeError, "Invalid object type for digest length.");
+
+	int digest_length_int = FIX2INT(digest_length);
+
+	check_digest_length(digest_length_int);
+
+	VALUE 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.");
+
+	KT_CONTEXT_PTR(ctx)->customization = customization;
+
+	if (KangarooTwelve_Initialize(&KT_CONTEXT_PTR(ctx)->instance, digest_length_int) != 0)
+		rb_raise(rb_eRuntimeError, "Failed to initialize hash data instance.");
+
+	return 1;
+}
+
+static void kangarootwelve_update(void *ctx, unsigned char *data, size_t length)
+{
+	if (ctx == NULL)
+		rb_raise(rb_eRuntimeError, "Context pointer is NULL.");
+
+	if (data == NULL)
+		rb_raise(rb_eRuntimeError, "Data pointer is NULL.");
+
+	if (KangarooTwelve_Update(&KT_CONTEXT_PTR(ctx)->instance, data, length) != 0)
+		rb_raise(rb_eRuntimeError, "Hash update failed.");
+}
+
+static int kangarootwelve_finish(void *ctx, unsigned char *data)
+{
+	if (ctx == NULL)
+		rb_raise(rb_eRuntimeError, "Context pointer is NULL.");
+
+	VALUE 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;
+	default:
+		rb_raise(rb_eRuntimeError, "Object type of customization string became invalid.");
+	}
+}
+
+static VALUE do_nothing(VALUE self)
+{
+	return Qnil;
+}
+
+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;
+		break;
+	case T_FIXNUM:
+		digest_length_int = FIX2INT(digest_length);
+		check_digest_length(digest_length);
+		break;
+	default:
+		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:
+		break;
+	default:
+		rb_raise(rb_eTypeError, "Invalid value type for customization string.");
+	}
+
+	VALUE impl_class_name = Qnil;
+	ID impl_class_name_id, id;
+
+	switch (TYPE(name)) {
+	case T_NIL:
+		break;
+	case T_SYMBOL:
+		id = SYM2ID(name);
+
+		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);
+			} else {
+				impl_class_name = rb_sprintf("KangarooTwelve_%d", digest_length_int);
+			}
+
+			impl_class_name_id = rb_intern_str(impl_class_name);
+		} else {
+			VALUE symbol_inspect = rb_inspect(name);
+			rb_raise(rb_eArgError, "Invalid symbol argument for class name: %s", StringValueCStr(symbol_inspect));
+		}
+
+		break;
+	case T_STRING:
+		id = rb_intern_str(name);
+
+		if (!rb_is_const_id(id))
+			rb_raise(rb_eArgError, "Not a valid class name: %s", StringValueCStr(name));
+
+		impl_class_name = name;
+		impl_class_name_id = id;
+		break;
+	default:
+		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);
+	} else {
+		if (rb_const_defined(_module_Digest, impl_class_name_id)) {
+			impl_class = rb_const_get(_module_Digest, impl_class_name_id);
+
+			if (TYPE(impl_class) != T_CLASS) {
+				rb_raise(rb_eTypeError,
+						"Digest::%s was already defined but is not a class.",
+						StringValueCStr(impl_class_name));
+			}
+
+			if (rb_class_superclass(impl_class) != _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);
+
+			if (TYPE(prev_digest_length) != T_FIXNUM) {
+				rb_raise(rb_eRuntimeError,
+						"Previous definition of Digest::%s has invalid digest length value type.",
+						StringValueCStr(impl_class_name));
+			}
+
+			int prev_digest_length_int = FIX2INT(prev_digest_length);
+
+			if (prev_digest_length_int != digest_length_int) {
+				rb_raise(rb_eTypeError,
+						"Digest::%s was already defined but has different digest length (%d instead of %d).",
+						StringValueCStr(impl_class_name),
+						prev_digest_length_int,
+						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);
+	}
+
+	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->api_version = RUBY_DIGEST_API_VERSION;
+	metadata->digest_len = digest_length_int;
+	metadata->block_len = block_length_int;
+	metadata->ctx_size = sizeof(KT_CONTEXT);
+	metadata->init_func = kangarootwelve_init;
+	metadata->update_func = kangarootwelve_update;
+	metadata->finish_func = kangarootwelve_finish;
+
+	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_customization, customization);
+
+	return impl_class;
+}
+
+/*
+ * Document-module: Digest::KangarooTwelve
+ *
+ * The Digest::KangarooTwelve module is the main component of the KangarooTwelve
+ * extension.
+ *
+ * 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.
+ *
+ * An example to this is <code>hash = Digest::KangarooTwelve[32].new</code>.
+ *
+ * The produced implementation class and the hash object can be used just like
+ * any other implementation classes and instances in Digest.
+ */
+
+/*
+ * call-seq: Digest::KangarooTwelve.default -> klass
+ *
+ * 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)
+{
+	VALUE default_ = rb_ivar_get(self, _id_default);
+
+	if (NIL_P(default_)) {
+		default_ = implement(ID2SYM(_id_auto), INT2FIX(KT_DEFAULT_DIGEST_LENGTH), Qnil, Qnil);
+		rb_ivar_set(self, _id_default, default_);
+	}
+
+	Check_Type(default_, T_CLASS);
+	return default_;
+}
+
+/*
+ * call-seq: Digest::KangarooTwelve.implement(**opts) -> klass
+ *
+ * The Digest::KangarooTwelve::implement method is more configurable than the
+ * Digest::KangarooTwelve::[] method, and can implement classes with
+ * customization strings, a custom block length, and a different or anonymous
+ * name.
+ *
+ * The method can be called with the following options:
+ *
+ * :n, :name ::
+ *   Specifies the name of the class, which would be placed in the Digest
+ *   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.
+ *
+ *   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>.
+ *
+ *   Specifying a string would make the method produce Digest::<string>.
+ *
+ *   Specifying +nil+ would produce an anonymous class. I.e., a class not
+ *   assigned to any constant, and has no name returned with Class#name,
+ *   but +nil+.
+ *
+ * :d, :digest_length ::
+ *   Specifies the digest length.
+ *
+ *   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
+ * Digest::KangarooTwelve::default method.
+ */
+VALUE rbx_Digest_KangarooTwelve_singleton_implement(int argc, VALUE *argv, VALUE self)
+{
+	VALUE opts, name, digest_length, block_length, customization;
+
+	rb_scan_args(argc, argv, "0:", &opts);
+
+	if (NIL_P(opts)) {
+		name = ID2SYM(_id_auto);
+		digest_length = block_length = customization = Qnil;
+	} else {
+		name = rb_hash_lookup2(opts, ID2SYM(_id_n), Qundef);
+
+		if (name == Qundef)
+			name = rb_hash_lookup2(opts, ID2SYM(_id_name), ID2SYM(_id_auto));
+
+		digest_length = rb_hash_lookup2(opts, ID2SYM(_id_d), Qundef);
+
+		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);
+	}
+
+	return implement(name, digest_length, block_length, customization);
+}
+
+/*
+ * call-seq: Digest::KangarooTwelve[digest_length] -> klass
+ *
+ * Creates an implementation class with specified digest length.  This method
+ * is the simpler form of Digest::KangarooTwelve.implement.
+ *
+ * The class is generated in the name form of
+ * 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)
+{
+	return implement(ID2SYM(_id_auto), digest_length, Qnil, Qnil);
+}
+
+/*
+ * Document-class: Digest::KangarooTwelve::Impl
+ *
+ * This is the base class for KangarooTwelve's implementation classes,
+ * and it adds additional class methods and instance methods to the methods
+ * provided by Digest::Base, which can be used with the implementaion classes
+ * and the hashing objects respectively.
+ */
+
+/*
+ * call-seq: new -> obj
+ *
+ * Creates a new object instance of the implementation class.
+ */
+VALUE rbx_Digest_KangarooTwelve_Impl_singleton_new(VALUE self)
+{
+	if (self == _class_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)
+		rb_raise(rb_eRuntimeError, "Metadata not set or invalid.  Please do not manually inherit KangarooTwelve.");
+
+	return rb_call_super(0, 0);
+}
+
+/*
+ * call-seq: digest_length -> int
+ *
+ * Returns configured digest length of the implementation class.
+ */
+VALUE rbx_Digest_KangarooTwelve_Impl_singleton_digest_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_digest_length);
+}
+
+/*
+ * call-seq: block_length -> int
+ *
+ * Returns configured block length of the implementation class.
+ */
+VALUE rbx_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);
+}
+
+/*
+ * call-seq: customization -> string or nil
+ *
+ * Returns configured customization string of the implementation class.
+ */
+VALUE rbx_Digest_KangarooTwelve_Impl_singleton_customization(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_customization);
+}
+
+/*
+ * call-seq: customization -> string or nil
+ *
+ * Returns configured customization string of the implementation object.
+ */
+VALUE rbx_Digest_KangarooTwelve_Impl_customization(VALUE self)
+{
+	VALUE customization;
+
+	if (rb_ivar_defined(self, _id_customization)) {
+		customization = rb_ivar_get(self, _id_customization);
+	} else {
+		VALUE klass = rb_obj_class(self);
+		customization = rb_ivar_get(klass, _id_customization);
+		rb_ivar_set(self, _id_customization, customization);
+	}
+
+	return customization;
+}
+
+/*
+ * call-seq: inspect -> string
+ *
+ * Returns a string in the format of #<implementation_class_name|digest_length|block_length|customization_string|digest>
+ */
+VALUE rbx_Digest_KangarooTwelve_inspect(VALUE self)
+{
+	VALUE klass = rb_obj_class(self);
+	VALUE 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);
+
+	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>"));
+}
+
+/*
+ * Init
+ */
+
+void Init_kangarootwelve()
+{
+	#define DEFINE_ID(x) _id_##x = rb_intern_const(#x);
+
+	DEFINE_ID(auto)
+	DEFINE_ID(block_length)
+	DEFINE_ID(b)
+	DEFINE_ID(customization)
+	DEFINE_ID(c)
+	DEFINE_ID(default)
+	DEFINE_ID(digest_length)
+	DEFINE_ID(d)
+	DEFINE_ID(hexdigest)
+	DEFINE_ID(metadata)
+	DEFINE_ID(name)
+	DEFINE_ID(new)
+	DEFINE_ID(n)
+	DEFINE_ID(unpack)
+
+	rb_require("digest");
+	_module_Digest = rb_path2class("Digest");
+	_class_Digest_Base = rb_path2class("Digest::Base");
+
+	#if 0
+	_module_Digest = rb_define_module("Digest"); /* Tell RDoc about Digest since it doesn't recognize rb_path2class. */
+	#endif
+
+	/*
+	 * module Digest::KangarooTwelve
+	 */
+
+	_module_Digest_KangarooTwelve = rb_define_module_under(_module_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);
+
+	/*
+	 * Currently 65536 bytes (8192 x 8)
+	 */
+
+	rb_define_const(_module_Digest_KangarooTwelve, "DEFAULT_BLOCK_LENGTH", INT2FIX(KT_DEFAULT_BLOCK_LENGTH));
+
+	/*
+	 * 64 bytes (512 bits)
+	 */
+
+	rb_define_const(_module_Digest_KangarooTwelve, "DEFAULT_DIGEST_LENGTH", INT2FIX(KT_DEFAULT_DIGEST_LENGTH));
+
+	/*
+	 * class Digest::KangarooTwelve::Impl < Digest::Base
+	 */
+
+	_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);
+
+	/*
+	 * class Digest::KangarooTwelve::Metadata < Data
+	 *
+	 * 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"));
+}