sha3 0.2.5 → 1.0.3

data/ext/sha3/digest.c

@@ -2,12 +2,12 @@
 
 #include "sha3.h"
 
-VALUE cDigest;
-VALUE eDigestError;
+VALUE cSHA3Digest;
+VALUE eSHA3DigestError;
 
 /*
  * == Notes
- *  
+ *
  *    ::Digest::Class call sequence ->
  *    | .alloc() ->
  *    | .new() ->
@@ -16,240 +16,255 @@ VALUE eDigestError;
  *    --| .alloc() ->
  *      | .copy() ->
  *      | .finish() ->
- *  
+ *
  */
 
-static void free_allox(MDX *mdx) 
+static void free_allox(MDX *mdx)
 {
-  if (mdx) {
-    if (mdx->state)
-      free(mdx->state);
+    if (mdx)
+    {
+        if (mdx->state)
+        {
+            free(mdx->state);
+        }
 
-    free(mdx);
-  } 
+        free(mdx);
+    }
 
-  return;
+    return;
 }
 
-static VALUE c_digest_alloc(VALUE klass) 
-{ 
-  MDX *mdx;
-  VALUE obj;
+static VALUE c_digest_alloc(VALUE klass)
+{
+    MDX *mdx;
+    VALUE obj;
 
-  mdx = (MDX *) malloc(sizeof(MDX));
-  if (!mdx)
-    rb_raise(eDigestError, "failed to allocate object memory");
+    mdx = (MDX *)malloc(sizeof(MDX));
+    if (!mdx)
+    {
+        rb_raise(eSHA3DigestError, "failed to allocate object memory");
+    }
 
-  mdx->state = (hashState *) malloc(sizeof(hashState));  
-  if (!mdx->state) {
-    free_allox(mdx);
-    rb_raise(eDigestError, "failed to allocate state memory");
-  }
+    mdx->state = (Keccak_HashInstance *)malloc(sizeof(Keccak_HashInstance));
+    if (!mdx->state)
+    {
+        free_allox(mdx);
+        rb_raise(eSHA3DigestError, "failed to allocate state memory");
+    }
 
-  obj = Data_Wrap_Struct(klass, 0, free_allox, mdx);
+    obj = Data_Wrap_Struct(klass, 0, free_allox, mdx);
 
-  memset(mdx->state, 0, sizeof(hashState));
-  mdx->hashbitlen = 0;
+    memset(mdx->state, 0, sizeof(Keccak_HashInstance));
+    mdx->hashbitlen = 0;
 
-  return obj;
+    return obj;
 }
 
 static VALUE c_digest_update(VALUE, VALUE);
 
+HashReturn c_keccak_hash_initialize(MDX *mdx)
+{
+    HashReturn r = FAIL;
+
+    switch (mdx->hashbitlen)
+    {
+    case 224:
+        r = Keccak_HashInitialize_SHA3_224(mdx->state);
+        break;
+    case 256:
+        r = Keccak_HashInitialize_SHA3_256(mdx->state);
+        break;
+    case 384:
+        r = Keccak_HashInitialize_SHA3_384(mdx->state);
+        break;
+    case 512:
+        r = Keccak_HashInitialize_SHA3_512(mdx->state);
+        break;
+    }
+
+    return r;
+}
+
 // SHA3::Digest.new(type, [data]) -> self
 static VALUE c_digest_init(int argc, VALUE *argv, VALUE self)
-{ 
-  MDX *mdx;
-  VALUE hlen, data;
-
-  rb_scan_args(argc, argv, "02", &hlen, &data);
-  GETMDX(self, mdx);
-
-  if (!NIL_P(hlen))
-    mdx->hashbitlen = get_hlen(hlen);
-  else
-    mdx->hashbitlen = 256;
-
-  if (Init(mdx->state, mdx->hashbitlen) != SUCCESS)
-    rb_raise(eDigestError, "failed to initialize algorithm state");
-
-  if (!NIL_P(data))
-    return c_digest_update(self, data);
+{
+    MDX *mdx;
+    VALUE hlen, data;
+
+    rb_scan_args(argc, argv, "02", &hlen, &data);
+    GETMDX(self, mdx);
+
+    if (!NIL_P(hlen))
+    {
+        mdx->hashbitlen = get_hlen(hlen);
+    }
+    else
+    {
+        mdx->hashbitlen = 256;
+    }
+
+    if (c_keccak_hash_initialize(mdx) != SUCCESS)
+    {
+        rb_raise(eSHA3DigestError, "failed to initialize algorithm state");
+    }
+
+    if (!NIL_P(data))
+    {
+        return c_digest_update(self, data);
+    }
 
-  return self;
+    return self;
 }
 
 // SHA3::Digest.update(data) -> self
-static VALUE c_digest_update(VALUE self, VALUE data) 
+static VALUE c_digest_update(VALUE self, VALUE data)
 {
-  MDX *mdx;
-  DataLength dlen;
+    MDX *mdx;
+    DataLength dlen;
 
-  StringValue(data);
-  GETMDX(self, mdx);
+    StringValue(data);
+    GETMDX(self, mdx);
 
-  dlen = (RSTRING_LEN(data) * 8);
+    dlen = (RSTRING_LEN(data) * 8);
 
-  if (Update(mdx->state, RSTRING_PTR(data), dlen) != SUCCESS)
-    rb_raise(eDigestError, "failed to update hash data");
+    if (Keccak_HashUpdate(mdx->state, (BitSequence *)RSTRING_PTR(data), dlen) != SUCCESS)
+    {
+        rb_raise(eSHA3DigestError, "failed to update hash data");
+    }
 
-  return self;
+    return self;
 }
 
 // SHA3::Digest.reset() -> self
-static VALUE c_digest_reset(VALUE self) 
+static VALUE c_digest_reset(VALUE self)
 {
-  MDX *mdx;
+    MDX *mdx;
 
-  GETMDX(self, mdx);
+    GETMDX(self, mdx);
 
-  memset(mdx->state, 0, sizeof(hashState));
+    memset(mdx->state, 0, sizeof(Keccak_HashInstance));
 
-  if (Init(mdx->state, mdx->hashbitlen) != SUCCESS)
-    rb_raise(eDigestError, "failed to reset internal state");
+    if (c_keccak_hash_initialize(mdx) != SUCCESS)
+    {
+        rb_raise(eSHA3DigestError, "failed to reset internal state");
+    }
 
-  return self;
+    return self;
 }
 
-// Fix: And, permanent reminder of a rookie mistake in c_digest_copy, comparing structs with ==/!= op
-// Fix: Woke-up after 2-hours of sleep, and for good reason. Fixed string comparison. Need to re-read K&R!
 static int cmp_states(MDX *mdx1, MDX *mdx2)
 {
     return (
-      (mdx1->hashbitlen == mdx2->hashbitlen) &&
-      (strcmp((const char *) mdx1->state->state, (const char *)mdx2->state->state) == 0) &&
-      (strcmp((const char *) mdx1->state->dataQueue, (const char *) mdx2->state->dataQueue) == 0) &&
-      (mdx1->state->rate == mdx2->state->rate) &&
-      (mdx1->state->capacity == mdx2->state->capacity) &&
-      (mdx1->state->bitsInQueue == mdx2->state->bitsInQueue) &&
-      (mdx1->state->fixedOutputLength == mdx2->state->fixedOutputLength) &&
-      (mdx1->state->squeezing == mdx2->state->squeezing) &&
-      (mdx1->state->bitsAvailableForSqueezing == mdx2->state->bitsAvailableForSqueezing)
-    );
+        (mdx1->hashbitlen == mdx2->hashbitlen) &&
+        (strcmp((const char *)mdx1->state->sponge.state, (const char *)mdx2->state->sponge.state) == 0) &&
+        (mdx1->state->sponge.rate == mdx2->state->sponge.rate) &&
+        (mdx1->state->sponge.byteIOIndex == mdx2->state->sponge.byteIOIndex) &&
+        (mdx1->state->sponge.squeezing == mdx2->state->sponge.squeezing) &&
+        (mdx1->state->fixedOutputLength == mdx2->state->fixedOutputLength) &&
+        (mdx1->state->delimitedSuffix == mdx2->state->delimitedSuffix));
 }
 
 // SHA3::Digest.copy(obj) -> self
 static VALUE c_digest_copy(VALUE self, VALUE obj)
 {
-  MDX *mdx1, *mdx2;
+    MDX *mdx1, *mdx2;
 
-  rb_check_frozen(self);
-  if (self == obj)
-    return self;
+    rb_check_frozen(self);
+    if (self == obj)
+    {
+        return self;
+    }
+
+    GETMDX(self, mdx1);
+    SAFEGETMDX(obj, mdx2);
 
-  GETMDX(self, mdx1);
-  SAFEGETMDX(obj, mdx2);
+    memcpy(mdx1->state, mdx2->state, sizeof(Keccak_HashInstance));
+    mdx1->hashbitlen = mdx2->hashbitlen;
 
-  memcpy(mdx1->state, mdx2->state, sizeof(hashState));
-  mdx1->hashbitlen = mdx2->hashbitlen;
+    // Fetch the data again to make sure it was copied
+    GETMDX(self, mdx1);
+    SAFEGETMDX(obj, mdx2);
 
-  // Fetch the data again to make sure it was copied
-  GETMDX(self, mdx1);
-  SAFEGETMDX(obj, mdx2);
-  if (!cmp_states(mdx1, mdx2))
-    rb_raise(eDigestError, "failed to copy state");
+    if (!cmp_states(mdx1, mdx2))
+    {
+        rb_raise(eSHA3DigestError, "failed to copy state");
+    }
 
-  return self;
+    return self;
 }
 
 // SHA3::Digest.digest_length -> Integer
 static VALUE c_digest_length(VALUE self)
 {
-  MDX *mdx;
-  GETMDX(self, mdx);
+    MDX *mdx;
+    GETMDX(self, mdx);
 
-  return ULL2NUM(mdx->hashbitlen / 8);
+    return ULL2NUM(mdx->hashbitlen / 8);
 }
 
 // SHA3::Digest.block_length -> Integer
-static VALUE c_digest_block_length(VALUE self) 
+static VALUE c_digest_block_length(VALUE self)
 {
-  MDX *mdx;
-  GETMDX(self, mdx);
+    MDX *mdx;
+    GETMDX(self, mdx);
 
-  return ULL2NUM(200 - (2 * (mdx->hashbitlen / 8)));
+    return ULL2NUM(200 - (2 * (mdx->hashbitlen / 8)));
 }
 
 // SHA3::Digest.name -> String
-static VALUE c_digest_name(VALUE self) 
+static VALUE c_digest_name(VALUE self)
 {
-  return rb_str_new2("SHA3");
+    return rb_str_new2("SHA3");
 }
 
 // SHA3::Digest.finish() -> String
-static VALUE c_digest_finish(int argc, VALUE *argv, VALUE self) 
+static VALUE c_digest_finish(int argc, VALUE *argv, VALUE self)
 {
-  MDX *mdx;
-  VALUE str;
-
-  rb_scan_args(argc, argv, "01", &str);
-  GETMDX(self, mdx);
-
-  if (NIL_P(str)) {
-    str = rb_str_new(0, mdx->hashbitlen / 8);
-  } 
-  else {
-    StringValue(str);
-    rb_str_resize(str, mdx->hashbitlen / 8);
-  }
-
-  if (Final(mdx->state, RSTRING_PTR(str)) != SUCCESS)
-    rb_raise(eDigestError, "failed to finalize digest");
-
-  return str;
-}
-
-// SHA3::Digest.compute(type, data, [datalen]) -> String (bytes)
-// TO-DO: styled output (hex)
-static VALUE c_digest_compute(int argc, VALUE *argv, VALUE self)
-{
-  VALUE hlen, data, dlen, str;
-  int hashbitlen;
-  DataLength datalen;
-
-  rb_scan_args(argc, argv, "21", &hlen, &data, &dlen);
-
-  hashbitlen = get_hlen(hlen);
-
-  StringValue(data);
-  
-  if (!NIL_P(dlen))
-    datalen = NUM2ULL(dlen);
-  else
-    datalen = (RSTRING_LEN(data) * 8);
-
-  str = rb_str_new(0, hashbitlen / 8);
-
-  if (Hash(hashbitlen, RSTRING_PTR(data), datalen, RSTRING_PTR(str)) != SUCCESS)
-    rb_raise(eDigestError, "failed to generate hash");
-
-  return str;
+    MDX *mdx;
+    VALUE str;
+
+    rb_scan_args(argc, argv, "01", &str);
+    GETMDX(self, mdx);
+
+    if (NIL_P(str))
+    {
+        str = rb_str_new(0, mdx->hashbitlen / 8);
+    }
+    else
+    {
+        StringValue(str);
+        rb_str_resize(str, mdx->hashbitlen / 8);
+    }
+
+    if (Keccak_HashFinal(mdx->state, (BitSequence *)RSTRING_PTR(str)) != SUCCESS)
+    {
+        rb_raise(eSHA3DigestError, "failed to finalize digest");
+    }
+
+    return str;
 }
 
 void Init_sha3_n_digest()
 {
-  rb_require("digest");
-
-  /* SHA3::Digest (class) */
-  cDigest = rb_define_class_under(mSHA3, "Digest", rb_path2class("Digest::Class"));
-  /* SHA3::Digest::DigestError (class) */ 
-  eDigestError = rb_define_class_under(cDigest, "DigestError", rb_eStandardError);
-
-  // SHA3::Digest (class) methods
-  rb_define_alloc_func(cDigest, c_digest_alloc);
-  rb_define_method(cDigest, "initialize", c_digest_init, -1);
-  rb_define_method(cDigest, "update", c_digest_update, 1);
-  rb_define_method(cDigest, "reset", c_digest_reset, 0);
-  rb_define_method(cDigest, "initialize_copy", c_digest_copy, 1);
-  rb_define_method(cDigest, "digest_length", c_digest_length, 0);
-  rb_define_method(cDigest, "block_length", c_digest_block_length, 0);
-  rb_define_method(cDigest, "name", c_digest_name, 0);
-  rb_define_private_method(cDigest, "finish", c_digest_finish, -1);
-
-  rb_define_alias(cDigest, "<<", "update");
-  
-  // SHA3 (module) functions (support bit operations)
-  rb_define_singleton_method(cDigest, "compute", c_digest_compute, -1);
-
-  return;
-}
+    rb_require("digest");
+
+    /* SHA3::Digest (class) */
+    cSHA3Digest = rb_define_class_under(mSHA3, "Digest", rb_path2class("Digest::Class"));
+    /* SHA3::Digest::DigestError (class) */
+    eSHA3DigestError = rb_define_class_under(cSHA3Digest, "DigestError", rb_eStandardError);
+
+    // SHA3::Digest (class) methods
+    rb_define_alloc_func(cSHA3Digest, c_digest_alloc);
+    rb_define_method(cSHA3Digest, "initialize", c_digest_init, -1);
+    rb_define_method(cSHA3Digest, "update", c_digest_update, 1);
+    rb_define_method(cSHA3Digest, "reset", c_digest_reset, 0);
+    rb_define_method(cSHA3Digest, "initialize_copy", c_digest_copy, 1);
+    rb_define_method(cSHA3Digest, "digest_length", c_digest_length, 0);
+    rb_define_method(cSHA3Digest, "block_length", c_digest_block_length, 0);
+    rb_define_method(cSHA3Digest, "name", c_digest_name, 0);
+    rb_define_private_method(cSHA3Digest, "finish", c_digest_finish, -1);
+
+    rb_define_alias(cSHA3Digest, "<<", "update");
+
+    return;
+}

data/ext/sha3/digest.h

@@ -3,38 +3,46 @@
 #ifndef _DIGEST_H_
 #define _DIGEST_H_
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
 // From ruby/ext/openssl/ossl_digest.c
-#define GETMDX(obj, mdx) do {                                    \
-  Data_Get_Struct((obj), MDX, (mdx));                            \
-  if (!(mdx)) {                                                  \
-    rb_raise(rb_eRuntimeError, "Digest data not initialized!");  \
-  }                                                              \
-} while (0)
-
-#define SAFEGETMDX(obj, mdx) do {                                \
-  if (!rb_obj_is_kind_of(obj, cDigest)) {                        \
-    rb_raise(rb_eTypeError, "wrong argument (%s)! (expected %s)",\
-             rb_obj_classname(obj), rb_class2name(cDigest));     \
-  }                                                              \
-  GETMDX(obj, mdx);                                              \
-} while(0)
-
-extern VALUE cDigest;
-extern VALUE eDigestError;
-
-typedef struct {
-  hashState *state;
-  int hashbitlen;
-} MDX;
-
-void Init_sha3_n_digest(void);
-
-#ifdef  __cplusplus
+#define GETMDX(obj, mdx)                                                \
+    do                                                                  \
+    {                                                                   \
+        Data_Get_Struct((obj), MDX, (mdx));                             \
+        if (!(mdx))                                                     \
+        {                                                               \
+            rb_raise(rb_eRuntimeError, "Digest data not initialized!"); \
+        }                                                               \
+    } while (0)
+
+#define SAFEGETMDX(obj, mdx)                                              \
+    do                                                                    \
+    {                                                                     \
+        if (!rb_obj_is_kind_of(obj, cSHA3Digest))                         \
+        {                                                                 \
+            rb_raise(rb_eTypeError, "wrong argument (%s)! (expected %s)", \
+                     rb_obj_classname(obj), rb_class2name(cSHA3Digest));  \
+        }                                                                 \
+        GETMDX(obj, mdx);                                                 \
+    } while (0)
+
+    extern VALUE cSHA3Digest;
+    extern VALUE eSHA3DigestError;
+
+    typedef struct
+    {
+        Keccak_HashInstance *state;
+        int hashbitlen;
+    } MDX;
+
+    void Init_sha3_n_digest(void);
+
+#ifdef __cplusplus
 }
 #endif
 
-#endif
+#endif

data/ext/sha3/extconf.rb

@@ -1,26 +1,26 @@
 require 'mkmf'
 require 'rbconfig'
 
-FileUtils.rm "#{$srcdir}/KeccakF-1600-opt.c", :force => true
-
 target_cpu = RbConfig::CONFIG['target_cpu']
 
 if 1.size == 4 and target_cpu =~ /i386|x86_32/   # x86 32bit optimized code
-  Logging::message "=== Using i386 optimized Keccak code ===\n"
-  FileUtils.cp "#{$srcdir}/KeccakF-1600-opt32.c-arch", "#{$srcdir}/KeccakF-1600-opt.c"
+  Logging::message "=== Using reference  ===\n"
+  FileUtils.cp Dir["#{$srcdir}/Reference/*"].collect { |f| File.expand_path(f) }, "#{$srcdir}/"
 elsif 1.size == 8 and target_cpu =~ /i686|x86_64/
-  Logging::message "=== Using i686 optimized Keccak code ===\n"
-  FileUtils.cp "#{$srcdir}/KeccakF-1600-opt64.c-arch", "#{$srcdir}/KeccakF-1600-opt.c"
-else # Ha? Use reference code -- slow
-  Logging::message "=== Using reference Keccak code ===\n"
-  FileUtils.cp "#{$srcdir}/KeccakF-1600-reference.c-arch", "#{$srcdir}/KeccakF-1600-opt.c"
+  Logging::message "=== Using optimized (64-bit) ===\n"
+  FileUtils.cp Dir["#{$srcdir}/Optimized64/*"].collect { |f| File.expand_path(f) }, "#{$srcdir}/"
+else
+  Logging::message "=== Using reference ===\n"
+  FileUtils.cp Dir["#{$srcdir}/Reference/*"].collect { |f| File.expand_path(f) }, "#{$srcdir}/"
 end
 
-find_header("KeccakF-1600-interface.h")
-find_header("KeccakSponge.h")
-find_header("KeccakNISTInterface.h")
 find_header("sha3.h")
 find_header("digest.h")
 
-$CFLAGS = ' -fomit-frame-pointer -O3 -g0 -march=nocona '
+$CFLAGS = ' -fomit-frame-pointer -O3 -g0'
+
+if enable_config('march-tune-native', false)
+  $CFLAGS += ' -march=native'
+end
+
 create_makefile 'sha3_n'

data/ext/sha3/sha3.c

@@ -7,40 +7,56 @@ VALUE eSHA3Error;
 
 int get_hlen(VALUE obj)
 {
-  int hlen;
-
-  if (TYPE(obj) == T_SYMBOL) {
-    ID symid;
-
-    symid = SYM2ID(obj);
-
-    if (rb_intern("sha224") == symid)
-      hlen = 224;
-    else if (rb_intern("sha256") == symid)
-      hlen = 256;
-    else if (rb_intern("sha384") == symid)
-      hlen = 384;
-    else if (rb_intern("sha512") == symid)
-      hlen = 512;
+    int hlen;
+
+    if (TYPE(obj) == T_SYMBOL)
+    {
+        ID symid;
+
+        symid = SYM2ID(obj);
+
+        if (rb_intern("sha224") == symid)
+        {
+            hlen = 224;
+        }
+        else if (rb_intern("sha256") == symid)
+        {
+            hlen = 256;
+        }
+        else if (rb_intern("sha384") == symid)
+        {
+            hlen = 384;
+        }
+        else if (rb_intern("sha512") == symid)
+        {
+            hlen = 512;
+        }
+        else
+        {
+            rb_raise(eSHA3Error, "invalid hash bit symbol (should be: :sha224, :sha256, :sha384, or :sha512");
+        }
+    }
+    else if (TYPE(obj) == T_FIXNUM)
+    {
+        hlen = NUM2INT(obj);
+
+        if ((hlen != 224) && (hlen != 256) && (hlen != 384) && (hlen != 512))
+        {
+            rb_raise(rb_eArgError, "invalid hash bit length (should be: 224, 256, 384, or 512)");
+        }
+    }
     else
-      rb_raise(eSHA3Error, "invalid hash bit symbol (should be: :sha224, :sha256, :sha384, or :sha512");
-  }
-  else if (TYPE(obj) == T_FIXNUM) {
-    hlen = NUM2INT(obj);
-
-    if ((hlen != 224) && (hlen != 256) && (hlen != 384) && (hlen != 512))
-      rb_raise(rb_eArgError, "invalid hash bit length (should be: 224, 256, 384, or 512)");
-  }
-  else
-    rb_raise(eSHA3Error, "unknown type value");
-
-  return hlen;
+    {
+        rb_raise(eSHA3Error, "unknown type value");
+    }
+
+    return hlen;
 }
 
 void Init_sha3_n()
 {
-  mSHA3 = rb_define_module("SHA3");
-  eSHA3Error = rb_define_class_under(mSHA3, "SHA3Error", rb_eStandardError);
+    mSHA3 = rb_define_module("SHA3");
+    eSHA3Error = rb_define_class_under(mSHA3, "SHA3Error", rb_eStandardError);
 
-  Init_sha3_n_digest();
+    Init_sha3_n_digest();
 }

data/ext/sha3/sha3.h

@@ -5,21 +5,22 @@
 
 #include <ruby.h>
 
-#include "KeccakNISTInterface.h"
+#include "KeccakHash.h"
 #include "digest.h"
 
-#ifdef  __cplusplus
-extern "C" {
+#ifdef __cplusplus
+extern "C"
+{
 #endif
 
-extern VALUE mSHA3;
-extern VALUE eSHA3Error;
+    extern VALUE mSHA3;
+    extern VALUE eSHA3Error;
 
-int get_hlen(VALUE);
-void Init_sha3_n(void);
+    int get_hlen(VALUE);
+    void Init_sha3_n(void);
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 }
 #endif
 
-#endif
+#endif