digest-sha3 1.0.0

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, 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,3 @@
+require 'mkmf'
+$CFLAGS << " -fvisibility=hidden"
+create_makefile('digest/sha3')

data/ext/digest/sha3.c

@@ -0,0 +1,137 @@
+#include "ruby.h"
+#include "KeccakNISTInterface.h"
+
+#define MAX_DIGEST_SIZE 64
+
+static VALUE mDigest, cSHA3;
+
+typedef struct {
+	hashState state;
+	int bitlen;
+} RbSHA3;
+
+static VALUE
+rb_sha3_alloc(VALUE klass) {
+	RbSHA3 *ctx;
+	
+	ctx = (RbSHA3 *) xmalloc(sizeof(RbSHA3));
+	ctx->bitlen = -1;
+	return Data_Wrap_Struct(klass, 0, xfree, ctx);
+}
+
+static VALUE
+rb_sha3_initialize(int argc, VALUE *argv, VALUE self) {
+	RbSHA3 *ctx;
+	VALUE hashlen;
+	int i_hashlen;
+
+	if (rb_scan_args(argc, argv, "01", &hashlen) == 0) {
+		i_hashlen = 512;
+	} else {
+		i_hashlen = NUM2INT(hashlen);
+	}
+	if (i_hashlen == 0) {
+		rb_raise(rb_eRuntimeError, "Unsupported hash length");
+	}
+
+	Data_Get_Struct(self, RbSHA3, ctx);
+	ctx->bitlen = i_hashlen;
+
+	switch (Init(&ctx->state, i_hashlen)) {
+	case SUCCESS:
+		return self;
+	case FAIL:
+		rb_raise(rb_eRuntimeError, "Unknown error");
+		return Qnil;
+	case BAD_HASHLEN:
+		rb_raise(rb_eRuntimeError, "Bad hash length (must be 0, 224, 256, 384 or 512)");
+		return Qnil;
+	default:
+		rb_raise(rb_eRuntimeError, "Unknown error code");
+		return Qnil;
+	}
+}
+
+static VALUE
+rb_sha3_initialize_copy(VALUE self, VALUE other) {
+	RbSHA3 *ctx_self, *ctx_other;
+
+	rb_check_frozen(self);
+	Data_Get_Struct(self, RbSHA3, ctx_self);
+	Data_Get_Struct(other, RbSHA3, ctx_other);
+	memcpy(&ctx_self->state, &ctx_other->state, sizeof(hashState));
+	ctx_self->bitlen = ctx_other->bitlen;
+	return self;
+}
+
+static VALUE
+rb_sha3_reset(VALUE self) {
+	RbSHA3 *ctx;
+
+	Data_Get_Struct(self, RbSHA3, ctx);
+	Init(&ctx->state, ctx->bitlen);
+	return self;
+}
+
+static VALUE
+rb_sha3_update(VALUE self, VALUE str) {
+	RbSHA3 *ctx;
+
+	Data_Get_Struct(self, RbSHA3, ctx);
+	Update(&ctx->state, RSTRING_PTR(str), RSTRING_LEN(str) * 8);
+	return self;
+}
+
+static VALUE
+rb_sha3_digest(VALUE self, VALUE str) {
+	RbSHA3 *ctx;
+	hashState state;
+	unsigned char digest[MAX_DIGEST_SIZE];
+
+	Data_Get_Struct(self, RbSHA3, ctx);
+	memcpy(&state, &ctx->state, sizeof(hashState));
+	Final(&state, digest);
+	return rb_str_new((const char *) digest, ctx->bitlen / 8);
+}
+
+static VALUE
+rb_sha3_singleton_digest(int argc, VALUE *argv, VALUE klass) {
+	VALUE data, hashlen;
+	int i_hashlen;
+	unsigned char digest[MAX_DIGEST_SIZE];
+
+	if (rb_scan_args(argc, argv, "11", &data, &hashlen) == 1) {
+		i_hashlen = 512;
+	} else {
+		i_hashlen = NUM2INT(hashlen);
+	}
+
+	switch (Hash(i_hashlen, RSTRING_PTR(data), RSTRING_LEN(data) * 8, digest)) {
+	case SUCCESS:
+		return rb_str_new(digest, i_hashlen / 8);
+	case FAIL:
+		rb_raise(rb_eRuntimeError, "Unknown error");
+		return Qnil;
+	case BAD_HASHLEN:
+		rb_raise(rb_eRuntimeError, "Bad hash length (must be 0, 224, 256, 384 or 512)");
+		return Qnil;
+	default:
+		rb_raise(rb_eRuntimeError, "Unknown error code");
+		return Qnil;
+	}
+}
+
+void __attribute__((visibility("default")))
+Init_sha3() {
+	mDigest = rb_define_module("Digest");
+	cSHA3 = rb_define_class_under(mDigest, "SHA3", rb_cObject);
+	rb_define_alloc_func(cSHA3, rb_sha3_alloc);
+	rb_define_method(cSHA3, "initialize", rb_sha3_initialize, -1);
+	rb_define_method(cSHA3, "initialize_copy",  rb_sha3_initialize_copy, 1);
+	rb_define_method(cSHA3, "reset",  rb_sha3_reset, 0);
+	rb_define_method(cSHA3, "update",  rb_sha3_update, 1);
+	rb_define_method(cSHA3, "<<",  rb_sha3_update, 1);
+	rb_define_method(cSHA3, "digest",  rb_sha3_digest, 0);
+	rb_define_singleton_method(cSHA3, "digest", rb_sha3_singleton_digest, -1);
+	rb_require("digest/sha3/helpers");
+}

data/lib/digest/sha3/helpers.rb

@@ -0,0 +1,20 @@
+# encoding: ascii
+Digest::SHA3.class_eval do
+  def self.hexdigest(*args)
+    force_ascii(digest(*args).unpack("H*").first)
+  end
+
+  def hexdigest
+    Digest::SHA3.force_ascii(digest.unpack("H*").first)
+  end
+
+  if ''.respond_to?(:force_encoding)
+    def self.force_ascii(str)
+      str.force_encoding('ascii')
+    end
+  else
+    def self.force_ascii(str)
+      str
+    end
+  end
+end