digest-sha3-patched 1.1.1

data/ext/digest/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/displayIntermediateValues.c

@@ -0,0 +1,117 @@
+/*
+The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
+Michaël Peeters and Gilles Van Assche. For more information, feedback or
+questions, please refer to our website: http://keccak.noekeon.org/
+
+Implementation by the designers,
+hereby denoted as "the implementer".
+
+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/
+*/
+
+#include <stdio.h>
+#include "displayIntermediateValues.h"
+#include "KeccakNISTInterface.h"
+
+FILE *intermediateValueFile = 0;
+int displayLevel = 0;
+
+void displaySetIntermediateValueFile(FILE *f)
+{
+    intermediateValueFile = f;
+}
+
+void displaySetLevel(int level)
+{
+    displayLevel = level;
+}
+
+void displayBytes(int level, const char *text, const unsigned char *bytes, unsigned int size)
+{
+    unsigned int i;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<size; i++)
+            fprintf(intermediateValueFile, "%02X ", bytes[i]);
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "\n");
+    }
+}
+
+void displayBits(int level, const char *text, const unsigned char *data, unsigned int size, int MSBfirst)
+{
+    unsigned int i, iByte, iBit;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<size; i++) {
+            iByte = i/8;
+            iBit = i%8;
+            if (MSBfirst)
+                fprintf(intermediateValueFile, "%d ", ((data[iByte] << iBit) & 0x80) != 0);
+            else
+                fprintf(intermediateValueFile, "%d ", ((data[iByte] >> iBit) & 0x01) != 0);
+        }
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "\n");
+    }
+}
+
+void displayStateAsBytes(int level, const char *text, const unsigned char *state)
+{
+    displayBytes(level, text, state, KeccakPermutationSizeInBytes);
+}
+
+void displayStateAs32bitWords(int level, const char *text, const unsigned int *state)
+{
+    unsigned int i;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<KeccakPermutationSize/64; i++) {
+            fprintf(intermediateValueFile, "%08X:%08X", (unsigned int)state[2*i+0], (unsigned int)state[2*i+1]);
+            if ((i%5) == 4)
+                fprintf(intermediateValueFile, "\n");
+            else
+                fprintf(intermediateValueFile, " ");
+        }
+    }
+}
+
+void displayStateAs64bitWords(int level, const char *text, const unsigned long long int *state)
+{
+    unsigned int i;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<KeccakPermutationSize/64; i++) {
+            fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] >> 32));
+            fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] & 0xFFFFFFFFULL));
+            if ((i%5) == 4)
+                fprintf(intermediateValueFile, "\n");
+            else
+                fprintf(intermediateValueFile, " ");
+        }
+    }
+}
+
+void displayRoundNumber(int level, unsigned int i)
+{
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "--- Round %d ---\n", i);
+        fprintf(intermediateValueFile, "\n");
+    }
+}
+
+void displayText(int level, const char *text)
+{
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s", text);
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "\n");
+    }
+}

data/ext/digest/displayIntermediateValues.h

@@ -0,0 +1,29 @@
+/*
+The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
+Michaël Peeters and Gilles Van Assche. For more information, feedback or
+questions, please refer to our website: http://keccak.noekeon.org/
+
+Implementation by the designers,
+hereby denoted as "the implementer".
+
+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 _displayIntermediateValues_h_
+#define _displayIntermediateValues_h_
+
+#include <stdio.h>
+
+void displaySetIntermediateValueFile(FILE *f);
+void displaySetLevel(int level);
+void displayBytes(int level, const char *text, const unsigned char *bytes, unsigned int size);
+void displayBits(int level, const char *text, const unsigned char *data, unsigned int size, int MSBfirst);
+void displayStateAsBytes(int level, const char *text, const unsigned char *state);
+void displayStateAs32bitWords(int level, const char *text, const unsigned int *state);
+void displayStateAs64bitWords(int level, const char *text, const unsigned long long int *state);
+void displayRoundNumber(int level, unsigned int i);
+void displayText(int level, const char *text);
+
+#endif

data/ext/digest/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+have_header('ruby/digest.h')
+have_func('rb_str_set_len')
+
+$CFLAGS << " -fvisibility=hidden"
+create_makefile('digest/sha3')

data/ext/digest/sha3.c

@@ -0,0 +1,153 @@
+#include "ruby.h"
+#ifdef HAVE_RUBY_DIGEST_H
+#include "ruby/digest.h"
+#else
+#include "digest.h"
+#endif
+#include "KeccakNISTInterface.h"
+
+#define MAX_DIGEST_SIZE 64
+#define DEFAULT_DIGEST_LEN 512
+
+static int sha3_init_func(hashState *ctx);
+static void sha3_update_func(hashState *ctx, unsigned char *str, size_t len);
+static int sha3_finish_func(hashState *ctx, unsigned char *digest);
+
+/*
+  Metadata definition for the SHA3 algorithm.
+  Defines the Version, sizes for block and digest as well as
+  the entry points for the algorithms
+*/
+static rb_digest_metadata_t sha3 = {
+	RUBY_DIGEST_API_VERSION,
+	DEFAULT_DIGEST_LEN,
+	KeccakPermutationSize - (2 * DEFAULT_DIGEST_LEN), //size of blocks
+	sizeof(hashState), //size of context for the object we'll be passed in below functions.
+	(rb_digest_hash_init_func_t)sha3_init_func,
+	(rb_digest_hash_update_func_t)sha3_update_func,
+	(rb_digest_hash_finish_func_t)sha3_finish_func,
+};
+
+/* Initialization function for the algorithm,
+   gets called during allocation of the digest object.
+   we override initialize to do custom hash size, so we don't care too much here.
+*/
+static int
+sha3_init_func(hashState *ctx) {
+  // Just return a 1 ' successful' we override the init function
+  // so this is not necessary
+  // the base class alloc calls this to initialize the algorithm
+  return 1;
+}
+
+/* Update function, take the current context and add str to it */
+static void
+sha3_update_func(hashState *ctx, unsigned char *str, size_t len) {
+	Update(ctx, str, len * 8);
+}
+
+/* Finish the hash calculation and return the finished string */
+static int
+sha3_finish_func(hashState *ctx, unsigned char *digest) {
+	Final(ctx, digest);
+	return 1;
+}
+
+/* Ruby method.  Digest::SHA3#finish()
+ * No Arguments
+ * @returns [String] Encoded Digest String
+ */
+static VALUE
+rb_sha3_finish(VALUE self) {
+  hashState *ctx;
+  VALUE digest;
+
+  ctx = (hashState *)RTYPEDDATA_DATA(self);
+  digest = rb_str_new(0, ctx->capacity / 2 / 8);
+  sha3_finish_func(ctx, (unsigned char *)RSTRING_PTR(digest));
+
+  return digest;
+}
+
+/* :nodoc: private method
+ * initialize the ctx with the bitlength
+ */
+static void
+sha3_init(hashState *ctx, size_t bitlen) {
+	switch (Init(ctx, bitlen)) {
+	case SUCCESS:
+		return;
+	case FAIL:
+		rb_raise(rb_eRuntimeError, "Unknown error");
+	case BAD_HASHLEN:
+		rb_raise(rb_eArgError, "Bad hash length (must be 0, 224, 256, 384 or 512)");
+	default:
+		rb_raise(rb_eRuntimeError, "Unknown error code");
+	}
+}
+
+/* Ruby method.  Digest::SHA3.new(hashlen)
+ * @param hashlen The length of hash, only supports 224, 256, 384 or 512
+ * @returns [Digest::SHA3] new object.
+ */
+static VALUE
+rb_sha3_initialize(int argc, VALUE *argv, VALUE self) {
+	hashState *ctx;
+	VALUE hashlen;
+	int i_hashlen;
+
+	if (rb_scan_args(argc, argv, "01", &hashlen) == 0) {
+		i_hashlen = DEFAULT_DIGEST_LEN;
+	} else {
+		i_hashlen = NUM2INT(hashlen);
+	}
+	if ( i_hashlen == 0) {
+		rb_raise(rb_eArgError, "Unsupported hash length");
+  }
+
+  ctx = (hashState *)RTYPEDDATA_DATA(self);
+	sha3_init(ctx, i_hashlen);
+
+	return rb_call_super(0, NULL);
+}
+
+/* Ruby method.  Digest::SHA3#digest_length
+ * @returns [Numeric] Length of the digest.
+ */
+static VALUE
+rb_sha3_digest_length(VALUE self) {
+	hashState *ctx;
+
+	ctx = (hashState *)RTYPEDDATA_DATA(self);
+	return INT2FIX(ctx->capacity / 2 / 8);
+}
+
+/* Ruby method.  Digest::SHA3#block_length
+ * @returns [Numeric] Length of blocks in this digest.
+ */
+static VALUE
+rb_sha3_block_length(VALUE self) {
+	hashState *ctx;
+
+	ctx = (hashState *)RTYPEDDATA_DATA(self);
+	return INT2FIX(ctx->rate / 8);
+}
+
+void __attribute__((visibility("default")))
+Init_sha3() {
+	VALUE mDigest, cDigest_Base, cSHA3;
+
+	rb_require("digest");
+
+	mDigest = rb_path2class("Digest");
+	cDigest_Base = rb_path2class("Digest::Base");
+
+	cSHA3 = rb_define_class_under(mDigest, "SHA3", cDigest_Base);
+
+	rb_iv_set(cSHA3, "metadata", Data_Wrap_Struct(0, 0, 0, (void *)&sha3));
+
+  rb_define_method(cSHA3, "initialize", rb_sha3_initialize, -1);
+  rb_define_method(cSHA3, "digest_length", rb_sha3_digest_length, 0);
+  rb_define_method(cSHA3, "block_length", rb_sha3_block_length, 0);
+  rb_define_method(cSHA3, "finish", rb_sha3_finish, 0);
+}