mhash 1.0 → 1.1

data/.gitignore

@@ -1,3 +1,7 @@
 ext/**/*.so
 ext/**/*.o
 ext/**/*.log
+ext/mhash/Makefile
+*.gem
+*.lock
+*.swp

data/README.md

@@ -0,0 +1,97 @@
+# ruby-mhash [![Build Status](https://travis-ci.org/TibshoOT/ruby-mhash.png?branch=master)](https://travis-ci.org/TibshoOT/ruby-mhash)
+
+Mhash wrapping library for Ruby.
+
+## Requirements
+
+You need mhash libray installed.
+
+### Debian/Ubuntu
+
+    $ sudo apt-get install libmhash-dev
+
+### FreeBSD (using ports)
+
+    # cd /usr/ports/security/mhash
+    # make install
+
+### Rubies
+
+Tested with Ruby:
+
+* 1.8.7
+* 1.9.2
+* 1.9.3
+* 2.0.0-preview1
+
+You have to setup rubygems.
+
+## Installation
+
+    gem install mhash
+
+or for development:
+
+    git clone https://github.com/TibshoOT/ruby-mhash.git
+    cd ruby-mhash/etx/mhash
+    [edit source files]
+    ruby extconf.rb
+    make
+    irb -r ./mhash.so
+    [test it !]
+
+
+## Documentation
+
+Just require mhash library and go !
+
+Mhash's module functions are explicit...
+
+```ruby
+
+require 'mhash'
+
+Mhash.gost("this is a test !")
+Mhash.crc32("this is a test !")
+Mhash.md5("this is a test !")
+Mhash.sha1("this is a test !")
+Mhash.haval256("this is a test !")
+Mhash.ripemd160("this is a test !")
+Mhash.tiger192("this is a test !")
+Mhash.gost("this is a test !")
+Mhash.crc32b("this is a test !")
+Mhash.haval224("this is a test !")
+Mhash.haval192("this is a test !")
+Mhash.haval160("this is a test !")
+Mhash.haval128("this is a test !")
+Mhash.tiger128("this is a test !")
+Mhash.tiger160("this is a test !")
+Mhash.sha256("this is a test !")
+Mhash.adler32("this is a test !")
+Mhash.sha224("this is a test !")
+Mhash.sha512("this is a test !")
+Mhash.sha384("this is a test !")
+Mhash.whirlpool("this is a test !")
+Mhash.ripemd128("this is a test !")
+Mhash.ripemd256("this is a test !")
+Mhash.ripemd320("this is a test !")
+Mhash.snefru128("this is a test !")
+Mhash.snefru256("this is a test !")
+
+```
+
+At this time, these functions return byte encoded string but if you want an hexdigest, you can do this:
+
+```ruby
+
+require 'mhash'
+
+hash = Mhash.gost("this is a test !").unpack("H*").first
+
+```
+
+In the next release of mhash gem, you will be able to get hexdigest directly.
+
+## Want a feature ? Problem ?
+
+Open an issue ;)

data/ext/mhash/extconf.rb

@@ -1,4 +1,7 @@
 require 'mkmf'
 
-have_library('mhash') or raise
+have_header('ruby.h') or raise "ruby.h did't find. Did you install ruby environment development ?"
+have_header('mhash.h') or raise "mhash.h did't find. Check your libmhash setup."
+have_library('mhash') or raise "libmhash did't find. Install it."
+
 create_makefile('mhash/mhash')

data/ext/mhash/mhash.c

@@ -1,13 +1,11 @@
 #include <ruby.h>
 #include <mhash.h>
+#include "mhash_ruby.h"
 #include "module_definitions.h"
 
-void Init_mhash();
-static VALUE m_mhash;
-
 void Init_mhash()
 {
-  static VALUE m_hash;
+  VALUE m_mhash;
 
   m_mhash = rb_define_module("Mhash");
 

data/ext/mhash/mhash_ruby.h

@@ -0,0 +1,6 @@
+#ifndef __MHASH_RUBY__
+#define __MHASH_RUBY__
+
+  void Init_mhash();
+
+#endif

data/ext/mhash/module_definitions.c

@@ -34,29 +34,55 @@ void mhash_define_consts(VALUE *m_mhash)
 void mhash_define_functions(VALUE *m_mhash)
 {
   rb_define_module_function(*m_mhash, "digest", mhash_rb_digest, 2);
+  rb_define_module_function(*m_mhash, "hexdigest", mhash_rb_hexdigest, 1);
   rb_define_module_function(*m_mhash, "crc32", mhash_rb_crc32, 1);
+  rb_define_module_function(*m_mhash, "crc32!", mhash_rb_crc32_hex, 1);
   rb_define_module_function(*m_mhash, "md5", mhash_rb_md5, 1);
+  rb_define_module_function(*m_mhash, "md5!", mhash_rb_md5_hex, 1);
   rb_define_module_function(*m_mhash, "sha1", mhash_rb_sha1, 1);
+  rb_define_module_function(*m_mhash, "sha1!", mhash_rb_sha1_hex, 1);
   rb_define_module_function(*m_mhash, "haval256", mhash_rb_haval256, 1);
+  rb_define_module_function(*m_mhash, "haval256!", mhash_rb_haval256_hex, 1);
   rb_define_module_function(*m_mhash, "ripemd160", mhash_rb_ripemd160, 1);
+  rb_define_module_function(*m_mhash, "ripemd160!", mhash_rb_ripemd160_hex, 1);
   rb_define_module_function(*m_mhash, "tiger192", mhash_rb_tiger192, 1);
+  rb_define_module_function(*m_mhash, "tiger192!", mhash_rb_tiger192_hex, 1);
   rb_define_module_function(*m_mhash, "gost", mhash_rb_gost, 1);
+  rb_define_module_function(*m_mhash, "gost!", mhash_rb_gost_hex, 1);
   rb_define_module_function(*m_mhash, "crc32b", mhash_rb_crc32b, 1);
+  rb_define_module_function(*m_mhash, "crc32b!", mhash_rb_crc32b_hex, 1);
   rb_define_module_function(*m_mhash, "haval224", mhash_rb_haval224, 1);
+  rb_define_module_function(*m_mhash, "haval224!", mhash_rb_haval224_hex, 1);
   rb_define_module_function(*m_mhash, "haval192", mhash_rb_haval192, 1);
+  rb_define_module_function(*m_mhash, "haval192!", mhash_rb_haval192_hex, 1);
   rb_define_module_function(*m_mhash, "haval160", mhash_rb_haval160, 1);
+  rb_define_module_function(*m_mhash, "haval160!", mhash_rb_haval160_hex, 1);
   rb_define_module_function(*m_mhash, "haval128", mhash_rb_haval128, 1);
+  rb_define_module_function(*m_mhash, "haval128!", mhash_rb_haval128_hex, 1);
   rb_define_module_function(*m_mhash, "tiger128", mhash_rb_tiger128, 1);
+  rb_define_module_function(*m_mhash, "tiger128!", mhash_rb_tiger128_hex, 1);
   rb_define_module_function(*m_mhash, "tiger160", mhash_rb_tiger160, 1);
+  rb_define_module_function(*m_mhash, "tiger160!", mhash_rb_tiger160_hex, 1);
   rb_define_module_function(*m_mhash, "sha256", mhash_rb_sha256, 1);
+  rb_define_module_function(*m_mhash, "sha256!", mhash_rb_sha256_hex, 1);
   rb_define_module_function(*m_mhash, "adler32", mhash_rb_adler32, 1);
+  rb_define_module_function(*m_mhash, "adler32!", mhash_rb_adler32_hex, 1);
   rb_define_module_function(*m_mhash, "sha224", mhash_rb_sha224, 1);
+  rb_define_module_function(*m_mhash, "sha224!", mhash_rb_sha224_hex, 1);
   rb_define_module_function(*m_mhash, "sha512", mhash_rb_sha512, 1);
+  rb_define_module_function(*m_mhash, "sha512!", mhash_rb_sha512_hex, 1);
   rb_define_module_function(*m_mhash, "sha384", mhash_rb_sha384, 1);
+  rb_define_module_function(*m_mhash, "sha384!", mhash_rb_sha384_hex, 1);
   rb_define_module_function(*m_mhash, "whirlpool", mhash_rb_whirlpool, 1);
+  rb_define_module_function(*m_mhash, "whirlpool!", mhash_rb_whirlpool_hex, 1);
   rb_define_module_function(*m_mhash, "ripemd128", mhash_rb_ripemd128, 1);
+  rb_define_module_function(*m_mhash, "ripemd128!", mhash_rb_ripemd128_hex, 1);
   rb_define_module_function(*m_mhash, "ripemd256", mhash_rb_ripemd256, 1);
+  rb_define_module_function(*m_mhash, "ripemd256!", mhash_rb_ripemd256_hex, 1);
   rb_define_module_function(*m_mhash, "ripemd320", mhash_rb_ripemd320, 1);
+  rb_define_module_function(*m_mhash, "ripemd320!", mhash_rb_ripemd320_hex, 1);
   rb_define_module_function(*m_mhash, "snefru128", mhash_rb_snefru128, 1);
+  rb_define_module_function(*m_mhash, "snefru128!", mhash_rb_snefru128_hex, 1);
   rb_define_module_function(*m_mhash, "snefru256", mhash_rb_snefru256, 1);
+  rb_define_module_function(*m_mhash, "snefru256!", mhash_rb_snefru256_hex, 1);
 }

data/ext/mhash/module_definitions.h

@@ -1,7 +1,7 @@
 #ifndef __MODULE_DEFINITIONS__
 #define __MODULE_DEFINITIONS__
 
-  void mhash_define_conts(VALUE *m_mhash);
+  void mhash_define_consts(VALUE *m_mhash);
   void mhash_define_functions(VALUE *m_mhash);
 
 #endif

data/ext/mhash/module_functions.c

@@ -10,141 +10,391 @@ VALUE mhash_rb_digest(VALUE self, VALUE hash_type, VALUE data_to_hash)
     unsigned int size_of_hash;
     char *hash;
 
-    td = mhash_init(FIX2INT(hash_type));
+    td = mhash_init(NUM2INT(hash_type));
     if (td == MHASH_FAILED)
        rb_raise(rb_eException, "Unable to init mhash - MHASH_FAILED");
     mhash(td, RSTRING_PTR(data_to_hash), RSTRING_LEN(data_to_hash));
     hash = mhash_end(td);
-    size_of_hash = mhash_get_block_size(FIX2INT(hash_type));
+    size_of_hash = mhash_get_block_size(NUM2INT(hash_type));
     rb_str_hash = rb_str_new2("");
-    for (i = 0; i < size_of_hash; i++) {
+    for (i = 0; i < size_of_hash; i++)
       rb_str_hash = rb_str_cat(rb_str_hash, (const char *) &hash[i], 1);
-    }
     free(hash);
     return (rb_str_hash);
 }
 
+// This code has been reajusted from String class unpack method.
+VALUE mhash_rb_hexdigest(VALUE self, VALUE data_to_hex)
+{
+  int bits = 0;
+  long len, j;
+  VALUE hex_digest;
+  char *s, *t;
+  static const char hexdigits[] = "0123456789abcdef";
+
+  s = RSTRING_PTR(data_to_hex);
+  len = RSTRING_LEN(data_to_hex) * 2;
+  hex_digest = rb_str_new(0, len);
+  t = RSTRING_PTR(hex_digest);
+  for (j = 0; j < len; j++)
+  {
+    if (j & 1)
+      bits <<= 4;
+    else
+      bits = *s++;
+    *t++ = hexdigits[(bits >> 4) & 15];
+  }
+  return (hex_digest);
+}
+
 VALUE mhash_rb_crc32(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(0), data_to_hash));
 }
 
+VALUE mhash_rb_crc32_hex(VALUE self, VALUE data_to_hash)
+{
+    VALUE hash;
+
+    hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(0),
+                              data_to_hash));
+    return (hash);
+}
+
+
 VALUE mhash_rb_md5(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(1), data_to_hash));
 }
 
+VALUE mhash_rb_md5_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(1),
+                            data_to_hash));
+  return (hash);
+}
+
+
 VALUE mhash_rb_sha1(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(2), data_to_hash));
 }
 
+VALUE mhash_rb_sha1_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(2),
+                            data_to_hash));
+  return (hash);
+}
+
+
 VALUE mhash_rb_haval256(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(3), data_to_hash));
 }
 
+VALUE mhash_rb_haval256_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(3),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_ripemd160(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(5), data_to_hash));
 }
 
+VALUE mhash_rb_ripemd160_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(5),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_tiger192(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(7), data_to_hash));
 }
 
+VALUE mhash_rb_tiger192_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(7),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_gost(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(8), data_to_hash));
 }
 
+VALUE mhash_rb_gost_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(8),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_crc32b(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(9), data_to_hash));
 }
 
+VALUE mhash_rb_crc32b_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(9),
+                            data_to_hash));
+  return (hash);
+}
 VALUE mhash_rb_haval224(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(10), data_to_hash));
 }
 
+VALUE mhash_rb_haval224_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(10),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_haval192(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(11), data_to_hash));
 }
 
+VALUE mhash_rb_haval192_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(11),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_haval160(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(12), data_to_hash));
 }
 
+VALUE mhash_rb_haval160_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(12),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_haval128(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(13), data_to_hash));
 }
 
+VALUE mhash_rb_haval128_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(13),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_tiger128(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(14), data_to_hash));
 }
 
+VALUE mhash_rb_tiger128_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(14),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_tiger160(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(15), data_to_hash));
 }
 
+VALUE mhash_rb_tiger160_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(15),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_sha256(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(17), data_to_hash));
 }
 
+VALUE mhash_rb_sha256_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(17),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_adler32(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(18), data_to_hash));
 }
 
+VALUE mhash_rb_adler32_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(18),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_sha224(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(19), data_to_hash));
 }
 
+VALUE mhash_rb_sha224_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(19),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_sha512(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(20), data_to_hash));
 }
 
+VALUE mhash_rb_sha512_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(20),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_sha384(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(21), data_to_hash));
 }
 
+VALUE mhash_rb_sha384_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(21),
+                                                  data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_whirlpool(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(22), data_to_hash));
 }
 
+VALUE mhash_rb_whirlpool_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(22),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_ripemd128(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(23), data_to_hash));
 }
 
+VALUE mhash_rb_ripemd128_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(23),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_ripemd256(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(24), data_to_hash));
 }
 
+VALUE mhash_rb_ripemd256_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(24),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_ripemd320(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(25), data_to_hash));
 }
 
+VALUE mhash_rb_ripemd320_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(25),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_snefru128(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(26), data_to_hash));
 }
 
+VALUE mhash_rb_snefru128_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(26),
+                            data_to_hash));
+  return (hash);
+}
+
 VALUE mhash_rb_snefru256(VALUE self, VALUE data_to_hash)
 {
   return (mhash_rb_digest(self, INT2NUM(27), data_to_hash));
 }
+
+VALUE mhash_rb_snefru256_hex(VALUE self, VALUE data_to_hash)
+{
+  VALUE hash;
+
+  hash = mhash_rb_hexdigest(self, mhash_rb_digest(self, INT2NUM(27),
+                            data_to_hash));
+  return (hash);
+}

data/ext/mhash/module_functions.h

@@ -2,31 +2,81 @@
 #define __MHASH_FUNCTIONS__
 
   VALUE mhash_rb_digest(VALUE self, VALUE hash_type, VALUE data_to_hash);
+  VALUE mhash_rb_hexdigest(VALUE self, VALUE data_to_hex);
 
   VALUE mhash_rb_crc32(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_crc32_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_md5(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_md5_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_sha1(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_sha1_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_haval256(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_haval256_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_ripemd160(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_ripemd160_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_tiger192(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_tiger192_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_gost(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_gost_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_crc32b(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_crc32b_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_haval224(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_haval224_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_haval192(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_haval192_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_haval160(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_haval160_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_haval128(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_haval128_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_tiger128(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_tiger128_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_tiger160(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_tiger160_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_sha256(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_sha256_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_adler32(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_adler32_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_sha224(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_sha224_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_sha512(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_sha512_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_sha384(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_sha384_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_whirlpool(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_whirlpool_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_ripemd128(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_ripemd128_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_ripemd256(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_ripemd256_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_ripemd320(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_ripemd320_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_snefru128(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_snefru128_hex(VALUE self, VALUE data_to_hash);
+
   VALUE mhash_rb_snefru256(VALUE self, VALUE data_to_hash);
+  VALUE mhash_rb_snefru256_hex(VALUE self, VALUE data_to_hash);
 
 #endif

data/lib/mhash.rb

@@ -1,5 +1,5 @@
 require 'mhash/mhash'
 
 module Mhash
-  VERSION = "1.0"
+  VERSION = "1.1"
 end

data/mhash.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |gem|
   gem.files = `git ls-files`.split("\n")
   gem.extensions = ["ext/mhash/extconf.rb"]
   gem.require_paths = ["lib", "ext"]
-  gem.version = "1.0"
+  gem.version = "1.1"
   gem.extra_rdoc_files = ["LICENSE.txt"]
   gem.licenses = ["BSD"]
 end

data/test/test_mhash.rb

@@ -7,64 +7,124 @@ class TestMhash < Test::Unit::TestCase
       @data = "hello\n\n"
     end
 
-    def test_gost_hash
-        hash = Mhash.ghost(@data)
+    def test_gost_hash_unpack
+        hash = Mhash.gost(@data)
         valid_digest = 'a2c0810ccbb997eb2e029e7e4186535ef4efae43fdcb49afb4933303f649f8db'
         assert_equal(valid_digest, hash.unpack("H*").first)
     end
 
-    def test_tiger192_hash
+    def test_gost_hash_hex
+      hash = Mhash.gost!(@data)
+      valid_digest = 'a2c0810ccbb997eb2e029e7e4186535ef4efae43fdcb49afb4933303f649f8db'
+      assert_equal(valid_digest, hash)
+    end
+
+    def test_tiger192_hash_unpack
         hash = Mhash.tiger192(@data)
         valid_digest = '3655e96f537401e1c5ac4197ac22594e6d0a740c664e7263'
         assert_equal(valid_digest, hash.unpack("H*").first)
     end
 
-    def test_sha1_hash
+    def test_tiger192_hash_hex
+      hash = Mhash.tiger192!(@data)
+      valid_digest = '3655e96f537401e1c5ac4197ac22594e6d0a740c664e7263'
+      assert_equal(valid_digest, hash)
+    end
+
+    def test_sha1_hash_unpack
         hash = Mhash.sha1(@data)
         valid_digest = '4588019fd3d2567f303815db6adfe489b2ee5f92'
         assert_equal(valid_digest, hash.unpack("H*").first)
     end
 
-    def test_sha256_hash
+    def test_sha1_hash_hex
+      hash = Mhash.sha1!(@data)
+      valid_digest = '4588019fd3d2567f303815db6adfe489b2ee5f92'
+      assert_equal(valid_digest, hash)
+    end
+
+    def test_sha256_hash_unpack
         hash = Mhash.sha256(@data)
         valid_digest = '50adea61fa4e77ab111b814716097abfd05f83a207b47eb4529bbd4f54e111e0'
         assert_equal(valid_digest, hash.unpack("H*").first)
     end
 
-    def test_md5_hash
+    def test_sha256_hash_hex
+      hash = Mhash.sha256!(@data)
+      valid_digest = '50adea61fa4e77ab111b814716097abfd05f83a207b47eb4529bbd4f54e111e0'
+      assert_equal(valid_digest, hash)
+    end
+
+    def test_md5_hash_unpack
         hash = Mhash.md5(@data)
         valid_digest = '14e273e6f416c4b90a071f59ac01206a'
         assert_equal(valid_digest, hash.unpack("H*").first)
     end
 
-    def test_whirlpool_hash
+    def test_md5_hash_hex
+      hash = Mhash.md5!(@data)
+      valid_digest = '14e273e6f416c4b90a071f59ac01206a'
+      assert_equal(valid_digest, hash)
+    end
+
+    def test_whirlpool_hash_unpack
         hash = Mhash.whirlpool(@data)
         valid_digest = 'adc277e898e7164962c1674c0c3984169534630428364dd43fc7e4e3e7222b6ccf7b7c4656f972f392d5580797b70125780ac860cb84de6f55ed043277d545d3'
         assert_equal(valid_digest, hash.unpack("H*").first)
     end
 
-    def test_ripemd160_hash
+    def test_whirlpool_hash_hex
+      hash = Mhash.whirlpool!(@data)
+      valid_digest = 'adc277e898e7164962c1674c0c3984169534630428364dd43fc7e4e3e7222b6ccf7b7c4656f972f392d5580797b70125780ac860cb84de6f55ed043277d545d3'
+      assert_equal(valid_digest, hash)
+    end
+
+    def test_ripemd160_hash_unpack
         hash = Mhash.ripemd160(@data)
         valid_digest = '52985141506d19e443281ad5c6e058871bb2f765'
         assert_equal(valid_digest, hash.unpack("H*").first)
     end
 
-    def test_haval256_hash
+    def test_ripemd160_hash_hex
+      hash = Mhash.ripemd160!(@data)
+      valid_digest = '52985141506d19e443281ad5c6e058871bb2f765'
+      assert_equal(valid_digest, hash)
+    end
+
+    def test_haval256_hash_unpack
         hash = Mhash.haval256(@data)
         valid_digest = '1b3aa948d5d867964d72b9320a648050725e2daac5898c2d9f09512b99e5f72f'
         assert_equal(valid_digest, hash.unpack("H*").first)
     end
 
-    def test_adler32_hash
+    def test_haval256_hash_hex
+      hash = Mhash.haval256!(@data)
+      valid_digest = '1b3aa948d5d867964d72b9320a648050725e2daac5898c2d9f09512b99e5f72f'
+      assert_equal(valid_digest, hash)
+    end
+
+    def test_adler32_hash_unpack
         hash = Mhash.adler32(@data)
         valid_digest = '2902740a'
         assert_equal(valid_digest, hash.unpack("H*").first)
     end
 
-    def test_snefru256_hash
+    def test_adler32_hash_hex
+      hash = Mhash.adler32!(@data)
+      valid_digest = '2902740a'
+      assert_equal(valid_digest, hash)
+    end
+
+    def test_snefru256_hash_unpack
         hash = Mhash.snefru256(@data)
         valid_digest = 'f33eb2a3152af27e719474e8888da43c53b1ea7a629796eb7a67ecc539fc29a8'
         assert_equal(valid_digest, hash.unpack("H*").first)
     end
 
+    def test_snefru256_hash_hex
+      hash = Mhash.snefru256!(@data)
+      valid_digest = 'f33eb2a3152af27e719474e8888da43c53b1ea7a629796eb7a67ecc539fc29a8'
+      assert_equal(valid_digest, hash)
+    end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mhash
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: '1.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-02 00:00:00.000000000 Z
+date: 2013-02-05 00:00:00.000000000 Z
 dependencies: []
 description: Mhash library extension for Ruby
 email:
@@ -24,10 +24,11 @@ files:
 - .travis.yml
 - Gemfile
 - LICENSE.txt
+- README.md
 - Rakefile
-- ext/mhash/Makefile
 - ext/mhash/extconf.rb
 - ext/mhash/mhash.c
+- ext/mhash/mhash_ruby.h
 - ext/mhash/module_definitions.c
 - ext/mhash/module_definitions.h
 - ext/mhash/module_functions.c
@@ -57,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Mhash library extension for Ruby

data/ext/mhash/Makefile

@@ -1,187 +0,0 @@
-
-SHELL = /bin/sh
-
-#### Start of system configuration section. ####
-
-srcdir = .
-topdir = /home/tibshoot/.rvm/rubies/ruby-1.9.2-p320/include/ruby-1.9.1
-hdrdir = /home/tibshoot/.rvm/rubies/ruby-1.9.2-p320/include/ruby-1.9.1
-arch_hdrdir = /home/tibshoot/.rvm/rubies/ruby-1.9.2-p320/include/ruby-1.9.1/$(arch)
-VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
-prefix = $(DESTDIR)/home/tibshoot/.rvm/rubies/ruby-1.9.2-p320
-rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
-exec_prefix = $(prefix)
-vendorhdrdir = $(rubyhdrdir)/vendor_ruby
-sitehdrdir = $(rubyhdrdir)/site_ruby
-rubyhdrdir = $(includedir)/$(RUBY_BASE_NAME)-$(ruby_version)
-vendordir = $(rubylibprefix)/vendor_ruby
-sitedir = $(rubylibprefix)/site_ruby
-ridir = $(datarootdir)/$(RI_BASE_NAME)
-mandir = $(datarootdir)/man
-localedir = $(datarootdir)/locale
-libdir = $(exec_prefix)/lib
-psdir = $(docdir)
-pdfdir = $(docdir)
-dvidir = $(docdir)
-htmldir = $(docdir)
-infodir = $(datarootdir)/info
-docdir = $(datarootdir)/doc/$(PACKAGE)
-oldincludedir = $(DESTDIR)/usr/include
-includedir = $(prefix)/include
-localstatedir = $(prefix)/var
-sharedstatedir = $(prefix)/com
-sysconfdir = $(prefix)/etc
-datadir = $(datarootdir)
-datarootdir = $(prefix)/share
-libexecdir = $(exec_prefix)/libexec
-sbindir = $(exec_prefix)/sbin
-bindir = $(exec_prefix)/bin
-rubylibdir = $(rubylibprefix)/$(ruby_version)
-archdir = $(rubylibdir)/$(arch)
-sitelibdir = $(sitedir)/$(ruby_version)
-sitearchdir = $(sitelibdir)/$(sitearch)
-vendorlibdir = $(vendordir)/$(ruby_version)
-vendorarchdir = $(vendorlibdir)/$(sitearch)
-
-CC = gcc
-CXX = g++
-LIBRUBY = $(LIBRUBY_SO)
-LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
-LIBRUBYARG_SHARED = -Wl,-R -Wl,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)
-LIBRUBYARG_STATIC = -Wl,-R -Wl,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static
-OUTFLAG = -o 
-COUTFLAG = -o 
-
-RUBY_EXTCONF_H = 
-cflags   =  $(optflags) $(debugflags) $(warnflags)
-optflags = -O3
-debugflags = -ggdb
-warnflags = -Wextra -Wno-unused-parameter -Wno-parentheses -Wpointer-arith -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long
-CFLAGS   = -fPIC $(cflags)  -fPIC 
-INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
-DEFS     = 
-CPPFLAGS =  -I/home/tibshoot/.rvm/usr/include  $(DEFS) $(cppflags)
-CXXFLAGS = $(CFLAGS) $(cxxflags)
-ldflags  = -L.  -rdynamic -Wl,-export-dynamic
-dldflags = 
-ARCH_FLAG = 
-DLDFLAGS = $(ldflags) $(dldflags)
-LDSHARED = $(CC) -shared
-LDSHAREDXX = $(CXX) -shared
-AR = ar
-EXEEXT = 
-
-RUBY_BASE_NAME = ruby
-RUBY_INSTALL_NAME = ruby
-RUBY_SO_NAME = ruby
-arch = x86_64-linux
-sitearch = $(arch)
-ruby_version = 1.9.1
-ruby = /home/tibshoot/.rvm/rubies/ruby-1.9.2-p320/bin/ruby
-RUBY = $(ruby)
-RM = rm -f
-RM_RF = $(RUBY) -run -e rm -- -rf
-RMDIRS = $(RUBY) -run -e rmdir -- -p
-MAKEDIRS = /bin/mkdir -p
-INSTALL = /usr/bin/install -c
-INSTALL_PROG = $(INSTALL) -m 0755
-INSTALL_DATA = $(INSTALL) -m 644
-COPY = cp
-
-#### End of system configuration section. ####
-
-preload = 
-
-libpath = . $(libdir) /home/tibshoot/.rvm/usr/lib
-LIBPATH =  -L. -L$(libdir) -Wl,-R$(libdir) -L/home/tibshoot/.rvm/usr/lib -Wl,-R/home/tibshoot/.rvm/usr/lib
-DEFFILE = 
-
-CLEANFILES = mkmf.log
-DISTCLEANFILES = 
-DISTCLEANDIRS = 
-
-extout = 
-extout_prefix = 
-target_prefix = /mhash
-LOCAL_LIBS = 
-LIBS = $(LIBRUBYARG_SHARED) -lmhash  -lpthread -lrt -ldl -lcrypt -lm   -lc
-SRCS = mhash.c module_definitions.c module_functions.c
-OBJS = mhash.o module_definitions.o module_functions.o
-TARGET = mhash
-DLLIB = $(TARGET).so
-EXTSTATIC = 
-STATIC_LIB = 
-
-BINDIR        = $(bindir)
-RUBYCOMMONDIR = $(sitedir)$(target_prefix)
-RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
-RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
-HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
-ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
-
-TARGET_SO     = $(DLLIB)
-CLEANLIBS     = $(TARGET).so 
-CLEANOBJS     = *.o  *.bak
-
-all:    $(DLLIB)
-static: $(STATIC_LIB)
-.PHONY: all install static install-so install-rb
-.PHONY: clean clean-so clean-rb
-
-clean-rb-default::
-clean-rb::
-clean-so::
-clean: clean-so clean-rb-default clean-rb
-		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
-
-distclean-rb-default::
-distclean-rb::
-distclean-so::
-distclean: clean distclean-so distclean-rb-default distclean-rb
-		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
-		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
-		@-$(RMDIRS) $(DISTCLEANDIRS)
-
-realclean: distclean
-install: install-so install-rb
-
-install-so: $(RUBYARCHDIR)
-install-so: $(RUBYARCHDIR)/$(DLLIB)
-$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
-	@-$(MAKEDIRS) $(@D)
-	$(INSTALL_PROG) $(DLLIB) $(@D)
-install-rb: pre-install-rb install-rb-default
-install-rb-default: pre-install-rb-default
-pre-install-rb: Makefile
-pre-install-rb-default: Makefile
-$(RUBYARCHDIR):
-	$(MAKEDIRS) $@
-
-site-install: site-install-so site-install-rb
-site-install-so: install-so
-site-install-rb: install-rb
-
-.SUFFIXES: .c .m .cc .cxx .cpp .C .o
-
-.cc.o:
-	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
-
-.cxx.o:
-	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
-
-.cpp.o:
-	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
-
-.C.o:
-	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
-
-.c.o:
-	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
-
-$(DLLIB): $(OBJS) Makefile
-	@-$(RM) $(@)
-	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
-
-
-
-$(OBJS): $(hdrdir)/ruby.h $(hdrdir)/ruby/defines.h $(arch_hdrdir)/ruby/config.h