digest-whirlpool 1.0.0

data/ext/digest/whirlpool/whirlpool-portability.h

@@ -0,0 +1,142 @@
+/**
+ * The Whirlpool hashing function.
+ *
+ * The Whirlpool algorithm was developed by
+ * Paulo S. L. M. Barreto and Vincent Rijmen.
+ *
+ * See
+ *      P.S.L.M. Barreto, V. Rijmen,
+ *      ``The Whirlpool hashing function,''
+ *      NESSIE submission, 2000 (tweaked version, 2001),
+ *      <https://www.cosic.esat.kuleuven.ac.be/nessie/workshop/submissions/whirlpool.zip>
+ *
+ * @version 3.0 (2003.03.12)
+ *
+ * Modified for use in this software package.
+ */
+
+#ifndef _WHIRLPOOL_PORTABILITY_H_
+#define _WHIRLPOOL_PORTABILITY_H_
+
+/* Definition of minimum-width integer types
+ * 
+ * u8   -> unsigned integer type, at least 8 bits, equivalent to unsigned char
+ * u16  -> unsigned integer type, at least 16 bits
+ * u32  -> unsigned integer type, at least 32 bits
+ *
+ * s8, s16, s32  -> signed counterparts of u8, u16, u32
+ *
+ * Always use macro's T8(), T16() or T32() to obtain exact-width results,
+ * i.e., to specify the size of the result of each expression.
+ */
+
+typedef signed char s8;
+typedef unsigned char u8;
+
+#if UINT_MAX >= 4294967295UL
+
+typedef signed short s16;
+typedef signed int s32;
+typedef unsigned short u16;
+typedef unsigned int u32;
+
+#define ONE32   0xffffffffU
+
+#else
+
+typedef signed int s16;
+typedef signed long s32;
+typedef unsigned int u16;
+typedef unsigned long u32;
+
+#define ONE32   0xffffffffUL
+
+#endif
+
+#define ONE8    0xffU
+#define ONE16   0xffffU
+
+#define T8(x)   ((x) & ONE8)
+#define T16(x)  ((x) & ONE16)
+#define T32(x)  ((x) & ONE32)
+
+#ifdef _MSC_VER
+typedef unsigned __int64 u64;
+typedef signed __int64 s64;
+#define LL(v)   (v##i64)
+#define ONE64   LL(0xffffffffffffffff)
+#else  /* !_MSC_VER */
+typedef unsigned long long u64;
+typedef signed long long s64;
+#define LL(v)   (v##ULL)
+#define ONE64   LL(0xffffffffffffffff)
+#endif /* ?_MSC_VER */
+#define T64(x)  ((x) & ONE64)
+#define ROTR64(v, n)   (((v) >> (n)) | T64((v) << (64 - (n))))
+/*
+ * Note: the test is used to detect native 64-bit architectures;
+ * if the unsigned long is strictly greater than 32-bit, it is
+ * assumed to be at least 64-bit. This will not work correctly
+ * on (old) 36-bit architectures (PDP-11 for instance).
+ *
+ * On non-64-bit architectures, "long long" is used.
+ */
+
+/*
+ * U8TO32_BIG(c) returns the 32-bit value stored in big-endian convention
+ * in the unsigned char array pointed to by c.
+ */
+#define U8TO32_BIG(c)  (((u32)T8(*(c)) << 24) | ((u32)T8(*((c) + 1)) << 16) | ((u32)T8(*((c) + 2)) << 8) | ((u32)T8(*((c) + 3))))
+
+/*
+ * U8TO32_LITTLE(c) returns the 32-bit value stored in little-endian convention
+ * in the unsigned char array pointed to by c.
+ */
+#define U8TO32_LITTLE(c)  (((u32)T8(*(c))) | ((u32)T8(*((c) + 1)) << 8) | (u32)T8(*((c) + 2)) << 16) | ((u32)T8(*((c) + 3)) << 24))
+
+/*
+ * U8TO32_BIG(c, v) stores the 32-bit-value v in big-endian convention
+ * into the unsigned char array pointed to by c.
+ */
+#define U32TO8_BIG(c, v)    do { u32 x = (v); u8 *d = (c); d[0] = T8(x >> 24); d[1] = T8(x >> 16); d[2] = T8(x >> 8); d[3] = T8(x); } while (0)
+
+/*
+ * U8TO32_LITTLE(c, v) stores the 32-bit-value v in little-endian convention
+ * into the unsigned char array pointed to by c.
+ */
+#define U32TO8_LITTLE(c, v)    do { u32 x = (v); u8 *d = (c); d[0] = T8(x); d[1] = T8(x >> 8); d[2] = T8(x >> 16); d[3] = T8(x >> 24); } while (0)
+
+/*
+ * ROTL32(v, n) returns the value of the 32-bit unsigned value v after
+ * a rotation of n bits to the left. It might be replaced by the appropriate
+ * architecture-specific macro.
+ *
+ * It evaluates v and n twice.
+ *
+ * The compiler might emit a warning if n is the constant 0. The result
+ * is undefined if n is greater than 31.
+ */
+#define ROTL32(v, n)   (T32((v) << (n)) | ((v) >> (32 - (n))))
+
+/*
+ * Whirlpool-specific definitions.
+ */
+
+#define DIGESTBYTES WP_DIGEST_SIZE
+#define DIGESTBITS  (8*DIGESTBYTES) /* 512 */
+
+#define WBLOCKBYTES 64
+#define WBLOCKBITS  (8*WBLOCKBYTES) /* 512 */
+
+#define LENGTHBYTES 32
+#define LENGTHBITS  (8*LENGTHBYTES) /* 256 */
+
+struct WP_Struct {
+	u8  bitLength[LENGTHBYTES]; /* global number of hashed bits (256-bit counter) */
+	u8  buffer[WBLOCKBYTES];	/* buffer of data to hash */
+	int bufferBits;		        /* current number of bits on the buffer */
+	int bufferPos;		        /* current (possibly incomplete) byte slot on the buffer */
+	u64 hash[DIGESTBYTES/8];    /* the hashing state */
+};
+
+#endif

data/ext/digest/whirlpool/whirlpool.c

@@ -0,0 +1,49 @@
+/************************************************
+
+  whirlpool.c - provides Digest::Whirlpool class
+
+  $Author$
+
+  Copyright (C) 2006 Akinori MUSHA
+
+  $Id$
+
+************************************************/
+
+#include "digest.h"
+#include "whirlpool-algorithm.h"
+#include "whirlpool-portability.h"
+
+static void WP_Update(WP_Struct * const, const unsigned char * const, size_t);
+
+static rb_digest_metadata_t whirlpool = {
+    RUBY_DIGEST_API_VERSION,
+    WP_DIGEST_SIZE,
+    WBLOCKBYTES, 
+    sizeof(WP_Struct),
+    (rb_digest_hash_init_func_t)WP_Init,
+    (rb_digest_hash_update_func_t)WP_Update,
+    (rb_digest_hash_finish_func_t)WP_Finalize,
+};
+
+static void
+WP_Update(WP_Struct * const wp, const unsigned char * const data, size_t len)
+{
+    WP_Add(data, len * 8, wp);
+}
+
+void
+Init_whirlpool()
+{
+    VALUE mDigest, cDigest_Base, cDigest_Whirlpool;
+
+    rb_require("digest");
+
+    mDigest = rb_path2class("Digest");
+    cDigest_Base = rb_path2class("Digest::Base");
+
+    cDigest_Whirlpool = rb_define_class_under(mDigest, "Whirlpool", cDigest_Base);
+
+    rb_ivar_set(cDigest_Whirlpool, rb_intern("metadata"),
+      Data_Wrap_Struct(rb_cObject, 0, 0, &whirlpool));
+}

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: digest-whirlpool
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Akinori MUSHA
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-13 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: |
+  This is a Digest module implementing the Whirlpool hashing algorithm.
+  The size of a Whirlpool hash value is 512 bits.
+
+email: knu@idaemons.org
+executables: []
+
+extensions: 
+- ext/digest/whirlpool/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- ext/digest/whirlpool/depend
+- ext/digest/whirlpool/extconf.rb
+- ext/digest/whirlpool/whirlpool-algorithm.c
+- ext/digest/whirlpool/whirlpool-algorithm.h
+- ext/digest/whirlpool/whirlpool-constants.h
+- ext/digest/whirlpool/whirlpool-portability.h
+- ext/digest/whirlpool/whirlpool.c
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/knu/ruby-digest-extra
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Digest module implementing the Whirlpool hashing algorithm
+test_files: []
+